vulkan_rust_sys/
bitmasks.rs

1///[`VkAccelerationStructureCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateFlagBitsKHR.html)
2#[repr(transparent)]
3#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4#[doc(alias = "VkAccelerationStructureCreateFlagBitsKHR")]
5pub struct AccelerationStructureCreateFlagBitsKHR(u32);
6impl AccelerationStructureCreateFlagBitsKHR {
7    #[inline]
8    pub const fn empty() -> Self {
9        Self(0u32)
10    }
11    #[inline]
12    pub const fn from_raw(value: u32) -> Self {
13        Self(value)
14    }
15    #[inline]
16    pub const fn as_raw(self) -> u32 {
17        self.0
18    }
19    #[inline]
20    pub const fn is_empty(self) -> bool {
21        self.0 == 0u32
22    }
23    #[inline]
24    pub const fn contains(self, other: Self) -> bool {
25        (self.0 & other.0) == other.0
26    }
27    #[inline]
28    pub const fn all() -> Self {
29        Self(13u32)
30    }
31    ///Bit 0.
32    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(1u32);
33    ///Bit 3.
34    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self(8u32);
35    ///Bit 2.
36    pub const MOTION: Self = Self(4u32);
37}
38impl core::ops::BitOr for AccelerationStructureCreateFlagBitsKHR {
39    type Output = Self;
40    #[inline]
41    fn bitor(self, rhs: Self) -> Self {
42        Self(self.0 | rhs.0)
43    }
44}
45impl core::ops::BitOrAssign for AccelerationStructureCreateFlagBitsKHR {
46    #[inline]
47    fn bitor_assign(&mut self, rhs: Self) {
48        self.0 |= rhs.0;
49    }
50}
51impl core::ops::BitAnd for AccelerationStructureCreateFlagBitsKHR {
52    type Output = Self;
53    #[inline]
54    fn bitand(self, rhs: Self) -> Self {
55        Self(self.0 & rhs.0)
56    }
57}
58impl core::ops::BitAndAssign for AccelerationStructureCreateFlagBitsKHR {
59    #[inline]
60    fn bitand_assign(&mut self, rhs: Self) {
61        self.0 &= rhs.0;
62    }
63}
64impl core::ops::BitXor for AccelerationStructureCreateFlagBitsKHR {
65    type Output = Self;
66    #[inline]
67    fn bitxor(self, rhs: Self) -> Self {
68        Self(self.0 ^ rhs.0)
69    }
70}
71impl core::ops::BitXorAssign for AccelerationStructureCreateFlagBitsKHR {
72    #[inline]
73    fn bitxor_assign(&mut self, rhs: Self) {
74        self.0 ^= rhs.0;
75    }
76}
77impl core::ops::Not for AccelerationStructureCreateFlagBitsKHR {
78    type Output = Self;
79    #[inline]
80    fn not(self) -> Self {
81        Self(!self.0)
82    }
83}
84impl core::fmt::Debug for AccelerationStructureCreateFlagBitsKHR {
85    #[allow(unused_mut, unused_variables)]
86    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
87        let mut first = true;
88        let mut remaining = self.0;
89        if remaining & Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0 != 0 {
90            if !first {
91                f.write_str(" | ")?;
92            }
93            f.write_str("DEVICE_ADDRESS_CAPTURE_REPLAY")?;
94            remaining &= !Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0;
95            first = false;
96        }
97        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0 != 0 {
98            if !first {
99                f.write_str(" | ")?;
100            }
101            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY")?;
102            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0;
103            first = false;
104        }
105        if remaining & Self::MOTION.0 != 0 {
106            if !first {
107                f.write_str(" | ")?;
108            }
109            f.write_str("MOTION")?;
110            remaining &= !Self::MOTION.0;
111            first = false;
112        }
113        if remaining != 0u32 {
114            if !first {
115                f.write_str(" | ")?;
116            }
117            write!(f, "{:#x}", remaining)?;
118        } else if first {
119            f.write_str("(empty)")?;
120        }
121        Ok(())
122    }
123}
124///[`VkAccessFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits.html)
125#[repr(transparent)]
126#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
127#[doc(alias = "VkAccessFlagBits")]
128pub struct AccessFlagBits(u32);
129impl AccessFlagBits {
130    #[inline]
131    pub const fn empty() -> Self {
132        Self(0u32)
133    }
134    #[inline]
135    pub const fn from_raw(value: u32) -> Self {
136        Self(value)
137    }
138    #[inline]
139    pub const fn as_raw(self) -> u32 {
140        self.0
141    }
142    #[inline]
143    pub const fn is_empty(self) -> bool {
144        self.0 == 0u32
145    }
146    #[inline]
147    pub const fn contains(self, other: Self) -> bool {
148        (self.0 & other.0) == other.0
149    }
150    #[inline]
151    pub const fn all() -> Self {
152        Self(268042239u32)
153    }
154    ///Bit 0.
155    pub const INDIRECT_COMMAND_READ: Self = Self(1u32);
156    ///Bit 1.
157    pub const INDEX_READ: Self = Self(2u32);
158    ///Bit 2.
159    pub const VERTEX_ATTRIBUTE_READ: Self = Self(4u32);
160    ///Bit 3.
161    pub const UNIFORM_READ: Self = Self(8u32);
162    ///Bit 4.
163    pub const INPUT_ATTACHMENT_READ: Self = Self(16u32);
164    ///Bit 5.
165    pub const SHADER_READ: Self = Self(32u32);
166    ///Bit 6.
167    pub const SHADER_WRITE: Self = Self(64u32);
168    ///Bit 7.
169    pub const COLOR_ATTACHMENT_READ: Self = Self(128u32);
170    ///Bit 8.
171    pub const COLOR_ATTACHMENT_WRITE: Self = Self(256u32);
172    ///Bit 9.
173    pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(512u32);
174    ///Bit 10.
175    pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(1024u32);
176    ///Bit 11.
177    pub const TRANSFER_READ: Self = Self(2048u32);
178    ///Bit 12.
179    pub const TRANSFER_WRITE: Self = Self(4096u32);
180    ///Bit 13.
181    pub const HOST_READ: Self = Self(8192u32);
182    ///Bit 14.
183    pub const HOST_WRITE: Self = Self(16384u32);
184    ///Bit 15.
185    pub const MEMORY_READ: Self = Self(32768u32);
186    ///Bit 16.
187    pub const MEMORY_WRITE: Self = Self(65536u32);
188    pub const NONE: Self = Self(0u32);
189    ///Bit 25.
190    pub const TRANSFORM_FEEDBACK_WRITE: Self = Self(33554432u32);
191    ///Bit 26.
192    pub const TRANSFORM_FEEDBACK_COUNTER_READ: Self = Self(67108864u32);
193    ///Bit 27.
194    pub const TRANSFORM_FEEDBACK_COUNTER_WRITE: Self = Self(134217728u32);
195    ///Bit 20.
196    pub const CONDITIONAL_RENDERING_READ: Self = Self(1048576u32);
197    ///Bit 19.
198    pub const COLOR_ATTACHMENT_READ_NONCOHERENT: Self = Self(524288u32);
199    ///Bit 21.
200    pub const ACCELERATION_STRUCTURE_READ: Self = Self(2097152u32);
201    ///Bit 22.
202    pub const ACCELERATION_STRUCTURE_WRITE: Self = Self(4194304u32);
203    pub const SHADING_RATE_IMAGE_READ: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ;
204    ///Bit 24.
205    pub const FRAGMENT_DENSITY_MAP_READ: Self = Self(16777216u32);
206    ///Bit 23.
207    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ: Self = Self(8388608u32);
208}
209impl core::ops::BitOr for AccessFlagBits {
210    type Output = Self;
211    #[inline]
212    fn bitor(self, rhs: Self) -> Self {
213        Self(self.0 | rhs.0)
214    }
215}
216impl core::ops::BitOrAssign for AccessFlagBits {
217    #[inline]
218    fn bitor_assign(&mut self, rhs: Self) {
219        self.0 |= rhs.0;
220    }
221}
222impl core::ops::BitAnd for AccessFlagBits {
223    type Output = Self;
224    #[inline]
225    fn bitand(self, rhs: Self) -> Self {
226        Self(self.0 & rhs.0)
227    }
228}
229impl core::ops::BitAndAssign for AccessFlagBits {
230    #[inline]
231    fn bitand_assign(&mut self, rhs: Self) {
232        self.0 &= rhs.0;
233    }
234}
235impl core::ops::BitXor for AccessFlagBits {
236    type Output = Self;
237    #[inline]
238    fn bitxor(self, rhs: Self) -> Self {
239        Self(self.0 ^ rhs.0)
240    }
241}
242impl core::ops::BitXorAssign for AccessFlagBits {
243    #[inline]
244    fn bitxor_assign(&mut self, rhs: Self) {
245        self.0 ^= rhs.0;
246    }
247}
248impl core::ops::Not for AccessFlagBits {
249    type Output = Self;
250    #[inline]
251    fn not(self) -> Self {
252        Self(!self.0)
253    }
254}
255impl core::fmt::Debug for AccessFlagBits {
256    #[allow(unused_mut, unused_variables)]
257    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
258        let mut first = true;
259        let mut remaining = self.0;
260        if remaining & Self::INDIRECT_COMMAND_READ.0 != 0 {
261            if !first {
262                f.write_str(" | ")?;
263            }
264            f.write_str("INDIRECT_COMMAND_READ")?;
265            remaining &= !Self::INDIRECT_COMMAND_READ.0;
266            first = false;
267        }
268        if remaining & Self::INDEX_READ.0 != 0 {
269            if !first {
270                f.write_str(" | ")?;
271            }
272            f.write_str("INDEX_READ")?;
273            remaining &= !Self::INDEX_READ.0;
274            first = false;
275        }
276        if remaining & Self::VERTEX_ATTRIBUTE_READ.0 != 0 {
277            if !first {
278                f.write_str(" | ")?;
279            }
280            f.write_str("VERTEX_ATTRIBUTE_READ")?;
281            remaining &= !Self::VERTEX_ATTRIBUTE_READ.0;
282            first = false;
283        }
284        if remaining & Self::UNIFORM_READ.0 != 0 {
285            if !first {
286                f.write_str(" | ")?;
287            }
288            f.write_str("UNIFORM_READ")?;
289            remaining &= !Self::UNIFORM_READ.0;
290            first = false;
291        }
292        if remaining & Self::INPUT_ATTACHMENT_READ.0 != 0 {
293            if !first {
294                f.write_str(" | ")?;
295            }
296            f.write_str("INPUT_ATTACHMENT_READ")?;
297            remaining &= !Self::INPUT_ATTACHMENT_READ.0;
298            first = false;
299        }
300        if remaining & Self::SHADER_READ.0 != 0 {
301            if !first {
302                f.write_str(" | ")?;
303            }
304            f.write_str("SHADER_READ")?;
305            remaining &= !Self::SHADER_READ.0;
306            first = false;
307        }
308        if remaining & Self::SHADER_WRITE.0 != 0 {
309            if !first {
310                f.write_str(" | ")?;
311            }
312            f.write_str("SHADER_WRITE")?;
313            remaining &= !Self::SHADER_WRITE.0;
314            first = false;
315        }
316        if remaining & Self::COLOR_ATTACHMENT_READ.0 != 0 {
317            if !first {
318                f.write_str(" | ")?;
319            }
320            f.write_str("COLOR_ATTACHMENT_READ")?;
321            remaining &= !Self::COLOR_ATTACHMENT_READ.0;
322            first = false;
323        }
324        if remaining & Self::COLOR_ATTACHMENT_WRITE.0 != 0 {
325            if !first {
326                f.write_str(" | ")?;
327            }
328            f.write_str("COLOR_ATTACHMENT_WRITE")?;
329            remaining &= !Self::COLOR_ATTACHMENT_WRITE.0;
330            first = false;
331        }
332        if remaining & Self::DEPTH_STENCIL_ATTACHMENT_READ.0 != 0 {
333            if !first {
334                f.write_str(" | ")?;
335            }
336            f.write_str("DEPTH_STENCIL_ATTACHMENT_READ")?;
337            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT_READ.0;
338            first = false;
339        }
340        if remaining & Self::DEPTH_STENCIL_ATTACHMENT_WRITE.0 != 0 {
341            if !first {
342                f.write_str(" | ")?;
343            }
344            f.write_str("DEPTH_STENCIL_ATTACHMENT_WRITE")?;
345            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT_WRITE.0;
346            first = false;
347        }
348        if remaining & Self::TRANSFER_READ.0 != 0 {
349            if !first {
350                f.write_str(" | ")?;
351            }
352            f.write_str("TRANSFER_READ")?;
353            remaining &= !Self::TRANSFER_READ.0;
354            first = false;
355        }
356        if remaining & Self::TRANSFER_WRITE.0 != 0 {
357            if !first {
358                f.write_str(" | ")?;
359            }
360            f.write_str("TRANSFER_WRITE")?;
361            remaining &= !Self::TRANSFER_WRITE.0;
362            first = false;
363        }
364        if remaining & Self::HOST_READ.0 != 0 {
365            if !first {
366                f.write_str(" | ")?;
367            }
368            f.write_str("HOST_READ")?;
369            remaining &= !Self::HOST_READ.0;
370            first = false;
371        }
372        if remaining & Self::HOST_WRITE.0 != 0 {
373            if !first {
374                f.write_str(" | ")?;
375            }
376            f.write_str("HOST_WRITE")?;
377            remaining &= !Self::HOST_WRITE.0;
378            first = false;
379        }
380        if remaining & Self::MEMORY_READ.0 != 0 {
381            if !first {
382                f.write_str(" | ")?;
383            }
384            f.write_str("MEMORY_READ")?;
385            remaining &= !Self::MEMORY_READ.0;
386            first = false;
387        }
388        if remaining & Self::MEMORY_WRITE.0 != 0 {
389            if !first {
390                f.write_str(" | ")?;
391            }
392            f.write_str("MEMORY_WRITE")?;
393            remaining &= !Self::MEMORY_WRITE.0;
394            first = false;
395        }
396        if remaining & Self::TRANSFORM_FEEDBACK_WRITE.0 != 0 {
397            if !first {
398                f.write_str(" | ")?;
399            }
400            f.write_str("TRANSFORM_FEEDBACK_WRITE")?;
401            remaining &= !Self::TRANSFORM_FEEDBACK_WRITE.0;
402            first = false;
403        }
404        if remaining & Self::TRANSFORM_FEEDBACK_COUNTER_READ.0 != 0 {
405            if !first {
406                f.write_str(" | ")?;
407            }
408            f.write_str("TRANSFORM_FEEDBACK_COUNTER_READ")?;
409            remaining &= !Self::TRANSFORM_FEEDBACK_COUNTER_READ.0;
410            first = false;
411        }
412        if remaining & Self::TRANSFORM_FEEDBACK_COUNTER_WRITE.0 != 0 {
413            if !first {
414                f.write_str(" | ")?;
415            }
416            f.write_str("TRANSFORM_FEEDBACK_COUNTER_WRITE")?;
417            remaining &= !Self::TRANSFORM_FEEDBACK_COUNTER_WRITE.0;
418            first = false;
419        }
420        if remaining & Self::CONDITIONAL_RENDERING_READ.0 != 0 {
421            if !first {
422                f.write_str(" | ")?;
423            }
424            f.write_str("CONDITIONAL_RENDERING_READ")?;
425            remaining &= !Self::CONDITIONAL_RENDERING_READ.0;
426            first = false;
427        }
428        if remaining & Self::COLOR_ATTACHMENT_READ_NONCOHERENT.0 != 0 {
429            if !first {
430                f.write_str(" | ")?;
431            }
432            f.write_str("COLOR_ATTACHMENT_READ_NONCOHERENT")?;
433            remaining &= !Self::COLOR_ATTACHMENT_READ_NONCOHERENT.0;
434            first = false;
435        }
436        if remaining & Self::ACCELERATION_STRUCTURE_READ.0 != 0 {
437            if !first {
438                f.write_str(" | ")?;
439            }
440            f.write_str("ACCELERATION_STRUCTURE_READ")?;
441            remaining &= !Self::ACCELERATION_STRUCTURE_READ.0;
442            first = false;
443        }
444        if remaining & Self::ACCELERATION_STRUCTURE_WRITE.0 != 0 {
445            if !first {
446                f.write_str(" | ")?;
447            }
448            f.write_str("ACCELERATION_STRUCTURE_WRITE")?;
449            remaining &= !Self::ACCELERATION_STRUCTURE_WRITE.0;
450            first = false;
451        }
452        if remaining & Self::FRAGMENT_DENSITY_MAP_READ.0 != 0 {
453            if !first {
454                f.write_str(" | ")?;
455            }
456            f.write_str("FRAGMENT_DENSITY_MAP_READ")?;
457            remaining &= !Self::FRAGMENT_DENSITY_MAP_READ.0;
458            first = false;
459        }
460        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0 != 0 {
461            if !first {
462                f.write_str(" | ")?;
463            }
464            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT_READ")?;
465            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0;
466            first = false;
467        }
468        if remaining != 0u32 {
469            if !first {
470                f.write_str(" | ")?;
471            }
472            write!(f, "{:#x}", remaining)?;
473        } else if first {
474            f.write_str("(empty)")?;
475        }
476        Ok(())
477    }
478}
479///[`VkAccessFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits2.html)
480#[repr(transparent)]
481#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
482#[doc(alias = "VkAccessFlagBits2")]
483pub struct AccessFlagBits2(u64);
484impl AccessFlagBits2 {
485    #[inline]
486    pub const fn empty() -> Self {
487        Self(0u64)
488    }
489    #[inline]
490    pub const fn from_raw(value: u64) -> Self {
491        Self(value)
492    }
493    #[inline]
494    pub const fn as_raw(self) -> u64 {
495        self.0
496    }
497    #[inline]
498    pub const fn is_empty(self) -> bool {
499        self.0 == 0u64
500    }
501    #[inline]
502    pub const fn contains(self, other: Self) -> bool {
503        (self.0 & other.0) == other.0
504    }
505    #[inline]
506    pub const fn all() -> Self {
507        Self(547679931907833855u64)
508    }
509    pub const _2_NONE: Self = Self(0u64);
510    ///Bit 0.
511    pub const _2_INDIRECT_COMMAND_READ: Self = Self(1u64);
512    ///Bit 1.
513    pub const _2_INDEX_READ: Self = Self(2u64);
514    ///Bit 2.
515    pub const _2_VERTEX_ATTRIBUTE_READ: Self = Self(4u64);
516    ///Bit 3.
517    pub const _2_UNIFORM_READ: Self = Self(8u64);
518    ///Bit 4.
519    pub const _2_INPUT_ATTACHMENT_READ: Self = Self(16u64);
520    ///Bit 5.
521    pub const _2_SHADER_READ: Self = Self(32u64);
522    ///Bit 6.
523    pub const _2_SHADER_WRITE: Self = Self(64u64);
524    ///Bit 7.
525    pub const _2_COLOR_ATTACHMENT_READ: Self = Self(128u64);
526    ///Bit 8.
527    pub const _2_COLOR_ATTACHMENT_WRITE: Self = Self(256u64);
528    ///Bit 9.
529    pub const _2_DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(512u64);
530    ///Bit 10.
531    pub const _2_DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(1024u64);
532    ///Bit 11.
533    pub const _2_TRANSFER_READ: Self = Self(2048u64);
534    ///Bit 12.
535    pub const _2_TRANSFER_WRITE: Self = Self(4096u64);
536    ///Bit 13.
537    pub const _2_HOST_READ: Self = Self(8192u64);
538    ///Bit 14.
539    pub const _2_HOST_WRITE: Self = Self(16384u64);
540    ///Bit 15.
541    pub const _2_MEMORY_READ: Self = Self(32768u64);
542    ///Bit 16.
543    pub const _2_MEMORY_WRITE: Self = Self(65536u64);
544    ///Bit 32.
545    pub const _2_SHADER_SAMPLED_READ: Self = Self(4294967296u64);
546    ///Bit 33.
547    pub const _2_SHADER_STORAGE_READ: Self = Self(8589934592u64);
548    ///Bit 34.
549    pub const _2_SHADER_STORAGE_WRITE: Self = Self(17179869184u64);
550    ///Bit 35.
551    pub const _2_VIDEO_DECODE_READ: Self = Self(34359738368u64);
552    ///Bit 36.
553    pub const _2_VIDEO_DECODE_WRITE: Self = Self(68719476736u64);
554    ///Bit 57.
555    pub const _2_SAMPLER_HEAP_READ: Self = Self(144115188075855872u64);
556    ///Bit 58.
557    pub const _2_RESOURCE_HEAP_READ: Self = Self(288230376151711744u64);
558    ///Bit 37.
559    pub const _2_VIDEO_ENCODE_READ: Self = Self(137438953472u64);
560    ///Bit 38.
561    pub const _2_VIDEO_ENCODE_WRITE: Self = Self(274877906944u64);
562    ///Bit 51.
563    pub const _2_SHADER_TILE_ATTACHMENT_READ_BIT: Self = Self(2251799813685248u64);
564    ///Bit 52.
565    pub const _2_SHADER_TILE_ATTACHMENT_WRITE_BIT: Self = Self(4503599627370496u64);
566    ///Bit 25.
567    pub const _2_TRANSFORM_FEEDBACK_WRITE: Self = Self(33554432u64);
568    ///Bit 26.
569    pub const _2_TRANSFORM_FEEDBACK_COUNTER_READ: Self = Self(67108864u64);
570    ///Bit 27.
571    pub const _2_TRANSFORM_FEEDBACK_COUNTER_WRITE: Self = Self(134217728u64);
572    ///Bit 20.
573    pub const _2_CONDITIONAL_RENDERING_READ: Self = Self(1048576u64);
574    ///Bit 23.
575    pub const _2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ: Self = Self(8388608u64);
576    pub const _2_SHADING_RATE_IMAGE_READ: Self = Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ;
577    ///Bit 21.
578    pub const _2_ACCELERATION_STRUCTURE_READ: Self = Self(2097152u64);
579    ///Bit 22.
580    pub const _2_ACCELERATION_STRUCTURE_WRITE: Self = Self(4194304u64);
581    ///Bit 24.
582    pub const _2_FRAGMENT_DENSITY_MAP_READ: Self = Self(16777216u64);
583    ///Bit 19.
584    pub const _2_COLOR_ATTACHMENT_READ_NONCOHERENT: Self = Self(524288u64);
585    ///Bit 41.
586    pub const _2_DESCRIPTOR_BUFFER_READ: Self = Self(2199023255552u64);
587    ///Bit 39.
588    pub const _2_INVOCATION_MASK_READ_BIT: Self = Self(549755813888u64);
589    ///Bit 40.
590    pub const _2_SHADER_BINDING_TABLE_READ: Self = Self(1099511627776u64);
591    ///Bit 44.
592    pub const _2_MICROMAP_READ: Self = Self(17592186044416u64);
593    ///Bit 45.
594    pub const _2_MICROMAP_WRITE: Self = Self(35184372088832u64);
595    ///Bit 42.
596    pub const _2_OPTICAL_FLOW_READ: Self = Self(4398046511104u64);
597    ///Bit 43.
598    pub const _2_OPTICAL_FLOW_WRITE: Self = Self(8796093022208u64);
599    ///Bit 47.
600    pub const _2_DATA_GRAPH_READ_BIT: Self = Self(140737488355328u64);
601    ///Bit 48.
602    pub const _2_DATA_GRAPH_WRITE_BIT: Self = Self(281474976710656u64);
603    ///Bit 55.
604    pub const _2_MEMORY_DECOMPRESSION_READ: Self = Self(36028797018963968u64);
605    ///Bit 56.
606    pub const _2_MEMORY_DECOMPRESSION_WRITE: Self = Self(72057594037927936u64);
607}
608impl core::ops::BitOr for AccessFlagBits2 {
609    type Output = Self;
610    #[inline]
611    fn bitor(self, rhs: Self) -> Self {
612        Self(self.0 | rhs.0)
613    }
614}
615impl core::ops::BitOrAssign for AccessFlagBits2 {
616    #[inline]
617    fn bitor_assign(&mut self, rhs: Self) {
618        self.0 |= rhs.0;
619    }
620}
621impl core::ops::BitAnd for AccessFlagBits2 {
622    type Output = Self;
623    #[inline]
624    fn bitand(self, rhs: Self) -> Self {
625        Self(self.0 & rhs.0)
626    }
627}
628impl core::ops::BitAndAssign for AccessFlagBits2 {
629    #[inline]
630    fn bitand_assign(&mut self, rhs: Self) {
631        self.0 &= rhs.0;
632    }
633}
634impl core::ops::BitXor for AccessFlagBits2 {
635    type Output = Self;
636    #[inline]
637    fn bitxor(self, rhs: Self) -> Self {
638        Self(self.0 ^ rhs.0)
639    }
640}
641impl core::ops::BitXorAssign for AccessFlagBits2 {
642    #[inline]
643    fn bitxor_assign(&mut self, rhs: Self) {
644        self.0 ^= rhs.0;
645    }
646}
647impl core::ops::Not for AccessFlagBits2 {
648    type Output = Self;
649    #[inline]
650    fn not(self) -> Self {
651        Self(!self.0)
652    }
653}
654impl core::fmt::Debug for AccessFlagBits2 {
655    #[allow(unused_mut, unused_variables)]
656    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
657        let mut first = true;
658        let mut remaining = self.0;
659        if remaining & Self::_2_INDIRECT_COMMAND_READ.0 != 0 {
660            if !first {
661                f.write_str(" | ")?;
662            }
663            f.write_str("_2_INDIRECT_COMMAND_READ")?;
664            remaining &= !Self::_2_INDIRECT_COMMAND_READ.0;
665            first = false;
666        }
667        if remaining & Self::_2_INDEX_READ.0 != 0 {
668            if !first {
669                f.write_str(" | ")?;
670            }
671            f.write_str("_2_INDEX_READ")?;
672            remaining &= !Self::_2_INDEX_READ.0;
673            first = false;
674        }
675        if remaining & Self::_2_VERTEX_ATTRIBUTE_READ.0 != 0 {
676            if !first {
677                f.write_str(" | ")?;
678            }
679            f.write_str("_2_VERTEX_ATTRIBUTE_READ")?;
680            remaining &= !Self::_2_VERTEX_ATTRIBUTE_READ.0;
681            first = false;
682        }
683        if remaining & Self::_2_UNIFORM_READ.0 != 0 {
684            if !first {
685                f.write_str(" | ")?;
686            }
687            f.write_str("_2_UNIFORM_READ")?;
688            remaining &= !Self::_2_UNIFORM_READ.0;
689            first = false;
690        }
691        if remaining & Self::_2_INPUT_ATTACHMENT_READ.0 != 0 {
692            if !first {
693                f.write_str(" | ")?;
694            }
695            f.write_str("_2_INPUT_ATTACHMENT_READ")?;
696            remaining &= !Self::_2_INPUT_ATTACHMENT_READ.0;
697            first = false;
698        }
699        if remaining & Self::_2_SHADER_READ.0 != 0 {
700            if !first {
701                f.write_str(" | ")?;
702            }
703            f.write_str("_2_SHADER_READ")?;
704            remaining &= !Self::_2_SHADER_READ.0;
705            first = false;
706        }
707        if remaining & Self::_2_SHADER_WRITE.0 != 0 {
708            if !first {
709                f.write_str(" | ")?;
710            }
711            f.write_str("_2_SHADER_WRITE")?;
712            remaining &= !Self::_2_SHADER_WRITE.0;
713            first = false;
714        }
715        if remaining & Self::_2_COLOR_ATTACHMENT_READ.0 != 0 {
716            if !first {
717                f.write_str(" | ")?;
718            }
719            f.write_str("_2_COLOR_ATTACHMENT_READ")?;
720            remaining &= !Self::_2_COLOR_ATTACHMENT_READ.0;
721            first = false;
722        }
723        if remaining & Self::_2_COLOR_ATTACHMENT_WRITE.0 != 0 {
724            if !first {
725                f.write_str(" | ")?;
726            }
727            f.write_str("_2_COLOR_ATTACHMENT_WRITE")?;
728            remaining &= !Self::_2_COLOR_ATTACHMENT_WRITE.0;
729            first = false;
730        }
731        if remaining & Self::_2_DEPTH_STENCIL_ATTACHMENT_READ.0 != 0 {
732            if !first {
733                f.write_str(" | ")?;
734            }
735            f.write_str("_2_DEPTH_STENCIL_ATTACHMENT_READ")?;
736            remaining &= !Self::_2_DEPTH_STENCIL_ATTACHMENT_READ.0;
737            first = false;
738        }
739        if remaining & Self::_2_DEPTH_STENCIL_ATTACHMENT_WRITE.0 != 0 {
740            if !first {
741                f.write_str(" | ")?;
742            }
743            f.write_str("_2_DEPTH_STENCIL_ATTACHMENT_WRITE")?;
744            remaining &= !Self::_2_DEPTH_STENCIL_ATTACHMENT_WRITE.0;
745            first = false;
746        }
747        if remaining & Self::_2_TRANSFER_READ.0 != 0 {
748            if !first {
749                f.write_str(" | ")?;
750            }
751            f.write_str("_2_TRANSFER_READ")?;
752            remaining &= !Self::_2_TRANSFER_READ.0;
753            first = false;
754        }
755        if remaining & Self::_2_TRANSFER_WRITE.0 != 0 {
756            if !first {
757                f.write_str(" | ")?;
758            }
759            f.write_str("_2_TRANSFER_WRITE")?;
760            remaining &= !Self::_2_TRANSFER_WRITE.0;
761            first = false;
762        }
763        if remaining & Self::_2_HOST_READ.0 != 0 {
764            if !first {
765                f.write_str(" | ")?;
766            }
767            f.write_str("_2_HOST_READ")?;
768            remaining &= !Self::_2_HOST_READ.0;
769            first = false;
770        }
771        if remaining & Self::_2_HOST_WRITE.0 != 0 {
772            if !first {
773                f.write_str(" | ")?;
774            }
775            f.write_str("_2_HOST_WRITE")?;
776            remaining &= !Self::_2_HOST_WRITE.0;
777            first = false;
778        }
779        if remaining & Self::_2_MEMORY_READ.0 != 0 {
780            if !first {
781                f.write_str(" | ")?;
782            }
783            f.write_str("_2_MEMORY_READ")?;
784            remaining &= !Self::_2_MEMORY_READ.0;
785            first = false;
786        }
787        if remaining & Self::_2_MEMORY_WRITE.0 != 0 {
788            if !first {
789                f.write_str(" | ")?;
790            }
791            f.write_str("_2_MEMORY_WRITE")?;
792            remaining &= !Self::_2_MEMORY_WRITE.0;
793            first = false;
794        }
795        if remaining & Self::_2_SHADER_SAMPLED_READ.0 != 0 {
796            if !first {
797                f.write_str(" | ")?;
798            }
799            f.write_str("_2_SHADER_SAMPLED_READ")?;
800            remaining &= !Self::_2_SHADER_SAMPLED_READ.0;
801            first = false;
802        }
803        if remaining & Self::_2_SHADER_STORAGE_READ.0 != 0 {
804            if !first {
805                f.write_str(" | ")?;
806            }
807            f.write_str("_2_SHADER_STORAGE_READ")?;
808            remaining &= !Self::_2_SHADER_STORAGE_READ.0;
809            first = false;
810        }
811        if remaining & Self::_2_SHADER_STORAGE_WRITE.0 != 0 {
812            if !first {
813                f.write_str(" | ")?;
814            }
815            f.write_str("_2_SHADER_STORAGE_WRITE")?;
816            remaining &= !Self::_2_SHADER_STORAGE_WRITE.0;
817            first = false;
818        }
819        if remaining & Self::_2_VIDEO_DECODE_READ.0 != 0 {
820            if !first {
821                f.write_str(" | ")?;
822            }
823            f.write_str("_2_VIDEO_DECODE_READ")?;
824            remaining &= !Self::_2_VIDEO_DECODE_READ.0;
825            first = false;
826        }
827        if remaining & Self::_2_VIDEO_DECODE_WRITE.0 != 0 {
828            if !first {
829                f.write_str(" | ")?;
830            }
831            f.write_str("_2_VIDEO_DECODE_WRITE")?;
832            remaining &= !Self::_2_VIDEO_DECODE_WRITE.0;
833            first = false;
834        }
835        if remaining & Self::_2_SAMPLER_HEAP_READ.0 != 0 {
836            if !first {
837                f.write_str(" | ")?;
838            }
839            f.write_str("_2_SAMPLER_HEAP_READ")?;
840            remaining &= !Self::_2_SAMPLER_HEAP_READ.0;
841            first = false;
842        }
843        if remaining & Self::_2_RESOURCE_HEAP_READ.0 != 0 {
844            if !first {
845                f.write_str(" | ")?;
846            }
847            f.write_str("_2_RESOURCE_HEAP_READ")?;
848            remaining &= !Self::_2_RESOURCE_HEAP_READ.0;
849            first = false;
850        }
851        if remaining & Self::_2_VIDEO_ENCODE_READ.0 != 0 {
852            if !first {
853                f.write_str(" | ")?;
854            }
855            f.write_str("_2_VIDEO_ENCODE_READ")?;
856            remaining &= !Self::_2_VIDEO_ENCODE_READ.0;
857            first = false;
858        }
859        if remaining & Self::_2_VIDEO_ENCODE_WRITE.0 != 0 {
860            if !first {
861                f.write_str(" | ")?;
862            }
863            f.write_str("_2_VIDEO_ENCODE_WRITE")?;
864            remaining &= !Self::_2_VIDEO_ENCODE_WRITE.0;
865            first = false;
866        }
867        if remaining & Self::_2_SHADER_TILE_ATTACHMENT_READ_BIT.0 != 0 {
868            if !first {
869                f.write_str(" | ")?;
870            }
871            f.write_str("_2_SHADER_TILE_ATTACHMENT_READ_BIT")?;
872            remaining &= !Self::_2_SHADER_TILE_ATTACHMENT_READ_BIT.0;
873            first = false;
874        }
875        if remaining & Self::_2_SHADER_TILE_ATTACHMENT_WRITE_BIT.0 != 0 {
876            if !first {
877                f.write_str(" | ")?;
878            }
879            f.write_str("_2_SHADER_TILE_ATTACHMENT_WRITE_BIT")?;
880            remaining &= !Self::_2_SHADER_TILE_ATTACHMENT_WRITE_BIT.0;
881            first = false;
882        }
883        if remaining & Self::_2_TRANSFORM_FEEDBACK_WRITE.0 != 0 {
884            if !first {
885                f.write_str(" | ")?;
886            }
887            f.write_str("_2_TRANSFORM_FEEDBACK_WRITE")?;
888            remaining &= !Self::_2_TRANSFORM_FEEDBACK_WRITE.0;
889            first = false;
890        }
891        if remaining & Self::_2_TRANSFORM_FEEDBACK_COUNTER_READ.0 != 0 {
892            if !first {
893                f.write_str(" | ")?;
894            }
895            f.write_str("_2_TRANSFORM_FEEDBACK_COUNTER_READ")?;
896            remaining &= !Self::_2_TRANSFORM_FEEDBACK_COUNTER_READ.0;
897            first = false;
898        }
899        if remaining & Self::_2_TRANSFORM_FEEDBACK_COUNTER_WRITE.0 != 0 {
900            if !first {
901                f.write_str(" | ")?;
902            }
903            f.write_str("_2_TRANSFORM_FEEDBACK_COUNTER_WRITE")?;
904            remaining &= !Self::_2_TRANSFORM_FEEDBACK_COUNTER_WRITE.0;
905            first = false;
906        }
907        if remaining & Self::_2_CONDITIONAL_RENDERING_READ.0 != 0 {
908            if !first {
909                f.write_str(" | ")?;
910            }
911            f.write_str("_2_CONDITIONAL_RENDERING_READ")?;
912            remaining &= !Self::_2_CONDITIONAL_RENDERING_READ.0;
913            first = false;
914        }
915        if remaining & Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0 != 0 {
916            if !first {
917                f.write_str(" | ")?;
918            }
919            f.write_str("_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ")?;
920            remaining &= !Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0;
921            first = false;
922        }
923        if remaining & Self::_2_ACCELERATION_STRUCTURE_READ.0 != 0 {
924            if !first {
925                f.write_str(" | ")?;
926            }
927            f.write_str("_2_ACCELERATION_STRUCTURE_READ")?;
928            remaining &= !Self::_2_ACCELERATION_STRUCTURE_READ.0;
929            first = false;
930        }
931        if remaining & Self::_2_ACCELERATION_STRUCTURE_WRITE.0 != 0 {
932            if !first {
933                f.write_str(" | ")?;
934            }
935            f.write_str("_2_ACCELERATION_STRUCTURE_WRITE")?;
936            remaining &= !Self::_2_ACCELERATION_STRUCTURE_WRITE.0;
937            first = false;
938        }
939        if remaining & Self::_2_FRAGMENT_DENSITY_MAP_READ.0 != 0 {
940            if !first {
941                f.write_str(" | ")?;
942            }
943            f.write_str("_2_FRAGMENT_DENSITY_MAP_READ")?;
944            remaining &= !Self::_2_FRAGMENT_DENSITY_MAP_READ.0;
945            first = false;
946        }
947        if remaining & Self::_2_COLOR_ATTACHMENT_READ_NONCOHERENT.0 != 0 {
948            if !first {
949                f.write_str(" | ")?;
950            }
951            f.write_str("_2_COLOR_ATTACHMENT_READ_NONCOHERENT")?;
952            remaining &= !Self::_2_COLOR_ATTACHMENT_READ_NONCOHERENT.0;
953            first = false;
954        }
955        if remaining & Self::_2_DESCRIPTOR_BUFFER_READ.0 != 0 {
956            if !first {
957                f.write_str(" | ")?;
958            }
959            f.write_str("_2_DESCRIPTOR_BUFFER_READ")?;
960            remaining &= !Self::_2_DESCRIPTOR_BUFFER_READ.0;
961            first = false;
962        }
963        if remaining & Self::_2_INVOCATION_MASK_READ_BIT.0 != 0 {
964            if !first {
965                f.write_str(" | ")?;
966            }
967            f.write_str("_2_INVOCATION_MASK_READ_BIT")?;
968            remaining &= !Self::_2_INVOCATION_MASK_READ_BIT.0;
969            first = false;
970        }
971        if remaining & Self::_2_SHADER_BINDING_TABLE_READ.0 != 0 {
972            if !first {
973                f.write_str(" | ")?;
974            }
975            f.write_str("_2_SHADER_BINDING_TABLE_READ")?;
976            remaining &= !Self::_2_SHADER_BINDING_TABLE_READ.0;
977            first = false;
978        }
979        if remaining & Self::_2_MICROMAP_READ.0 != 0 {
980            if !first {
981                f.write_str(" | ")?;
982            }
983            f.write_str("_2_MICROMAP_READ")?;
984            remaining &= !Self::_2_MICROMAP_READ.0;
985            first = false;
986        }
987        if remaining & Self::_2_MICROMAP_WRITE.0 != 0 {
988            if !first {
989                f.write_str(" | ")?;
990            }
991            f.write_str("_2_MICROMAP_WRITE")?;
992            remaining &= !Self::_2_MICROMAP_WRITE.0;
993            first = false;
994        }
995        if remaining & Self::_2_OPTICAL_FLOW_READ.0 != 0 {
996            if !first {
997                f.write_str(" | ")?;
998            }
999            f.write_str("_2_OPTICAL_FLOW_READ")?;
1000            remaining &= !Self::_2_OPTICAL_FLOW_READ.0;
1001            first = false;
1002        }
1003        if remaining & Self::_2_OPTICAL_FLOW_WRITE.0 != 0 {
1004            if !first {
1005                f.write_str(" | ")?;
1006            }
1007            f.write_str("_2_OPTICAL_FLOW_WRITE")?;
1008            remaining &= !Self::_2_OPTICAL_FLOW_WRITE.0;
1009            first = false;
1010        }
1011        if remaining & Self::_2_DATA_GRAPH_READ_BIT.0 != 0 {
1012            if !first {
1013                f.write_str(" | ")?;
1014            }
1015            f.write_str("_2_DATA_GRAPH_READ_BIT")?;
1016            remaining &= !Self::_2_DATA_GRAPH_READ_BIT.0;
1017            first = false;
1018        }
1019        if remaining & Self::_2_DATA_GRAPH_WRITE_BIT.0 != 0 {
1020            if !first {
1021                f.write_str(" | ")?;
1022            }
1023            f.write_str("_2_DATA_GRAPH_WRITE_BIT")?;
1024            remaining &= !Self::_2_DATA_GRAPH_WRITE_BIT.0;
1025            first = false;
1026        }
1027        if remaining & Self::_2_MEMORY_DECOMPRESSION_READ.0 != 0 {
1028            if !first {
1029                f.write_str(" | ")?;
1030            }
1031            f.write_str("_2_MEMORY_DECOMPRESSION_READ")?;
1032            remaining &= !Self::_2_MEMORY_DECOMPRESSION_READ.0;
1033            first = false;
1034        }
1035        if remaining & Self::_2_MEMORY_DECOMPRESSION_WRITE.0 != 0 {
1036            if !first {
1037                f.write_str(" | ")?;
1038            }
1039            f.write_str("_2_MEMORY_DECOMPRESSION_WRITE")?;
1040            remaining &= !Self::_2_MEMORY_DECOMPRESSION_WRITE.0;
1041            first = false;
1042        }
1043        if remaining != 0u64 {
1044            if !first {
1045                f.write_str(" | ")?;
1046            }
1047            write!(f, "{:#x}", remaining)?;
1048        } else if first {
1049            f.write_str("(empty)")?;
1050        }
1051        Ok(())
1052    }
1053}
1054///[`VkAccessFlagBits3KHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits3KHR.html)
1055#[repr(transparent)]
1056#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1057#[doc(alias = "VkAccessFlagBits3KHR")]
1058pub struct AccessFlagBits3KHR(u64);
1059impl AccessFlagBits3KHR {
1060    #[inline]
1061    pub const fn empty() -> Self {
1062        Self(0u64)
1063    }
1064    #[inline]
1065    pub const fn from_raw(value: u64) -> Self {
1066        Self(value)
1067    }
1068    #[inline]
1069    pub const fn as_raw(self) -> u64 {
1070        self.0
1071    }
1072    #[inline]
1073    pub const fn is_empty(self) -> bool {
1074        self.0 == 0u64
1075    }
1076    #[inline]
1077    pub const fn contains(self, other: Self) -> bool {
1078        (self.0 & other.0) == other.0
1079    }
1080    #[inline]
1081    pub const fn all() -> Self {
1082        Self(0u64)
1083    }
1084    pub const ACCESS_3_NONE: Self = Self(0u64);
1085}
1086impl core::ops::BitOr for AccessFlagBits3KHR {
1087    type Output = Self;
1088    #[inline]
1089    fn bitor(self, rhs: Self) -> Self {
1090        Self(self.0 | rhs.0)
1091    }
1092}
1093impl core::ops::BitOrAssign for AccessFlagBits3KHR {
1094    #[inline]
1095    fn bitor_assign(&mut self, rhs: Self) {
1096        self.0 |= rhs.0;
1097    }
1098}
1099impl core::ops::BitAnd for AccessFlagBits3KHR {
1100    type Output = Self;
1101    #[inline]
1102    fn bitand(self, rhs: Self) -> Self {
1103        Self(self.0 & rhs.0)
1104    }
1105}
1106impl core::ops::BitAndAssign for AccessFlagBits3KHR {
1107    #[inline]
1108    fn bitand_assign(&mut self, rhs: Self) {
1109        self.0 &= rhs.0;
1110    }
1111}
1112impl core::ops::BitXor for AccessFlagBits3KHR {
1113    type Output = Self;
1114    #[inline]
1115    fn bitxor(self, rhs: Self) -> Self {
1116        Self(self.0 ^ rhs.0)
1117    }
1118}
1119impl core::ops::BitXorAssign for AccessFlagBits3KHR {
1120    #[inline]
1121    fn bitxor_assign(&mut self, rhs: Self) {
1122        self.0 ^= rhs.0;
1123    }
1124}
1125impl core::ops::Not for AccessFlagBits3KHR {
1126    type Output = Self;
1127    #[inline]
1128    fn not(self) -> Self {
1129        Self(!self.0)
1130    }
1131}
1132impl core::fmt::Debug for AccessFlagBits3KHR {
1133    #[allow(unused_mut, unused_variables)]
1134    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1135        let mut first = true;
1136        let mut remaining = self.0;
1137        if remaining != 0u64 {
1138            if !first {
1139                f.write_str(" | ")?;
1140            }
1141            write!(f, "{:#x}", remaining)?;
1142        } else if first {
1143            f.write_str("(empty)")?;
1144        }
1145        Ok(())
1146    }
1147}
1148///[`VkAcquireProfilingLockFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireProfilingLockFlagBitsKHR.html)
1149#[repr(transparent)]
1150#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1151#[doc(alias = "VkAcquireProfilingLockFlagBitsKHR")]
1152pub struct AcquireProfilingLockFlagBitsKHR(u32);
1153impl AcquireProfilingLockFlagBitsKHR {
1154    #[inline]
1155    pub const fn empty() -> Self {
1156        Self(0u32)
1157    }
1158    #[inline]
1159    pub const fn from_raw(value: u32) -> Self {
1160        Self(value)
1161    }
1162    #[inline]
1163    pub const fn as_raw(self) -> u32 {
1164        self.0
1165    }
1166    #[inline]
1167    pub const fn is_empty(self) -> bool {
1168        self.0 == 0u32
1169    }
1170    #[inline]
1171    pub const fn contains(self, other: Self) -> bool {
1172        (self.0 & other.0) == other.0
1173    }
1174    #[inline]
1175    pub const fn all() -> Self {
1176        Self(0u32)
1177    }
1178}
1179impl core::ops::BitOr for AcquireProfilingLockFlagBitsKHR {
1180    type Output = Self;
1181    #[inline]
1182    fn bitor(self, rhs: Self) -> Self {
1183        Self(self.0 | rhs.0)
1184    }
1185}
1186impl core::ops::BitOrAssign for AcquireProfilingLockFlagBitsKHR {
1187    #[inline]
1188    fn bitor_assign(&mut self, rhs: Self) {
1189        self.0 |= rhs.0;
1190    }
1191}
1192impl core::ops::BitAnd for AcquireProfilingLockFlagBitsKHR {
1193    type Output = Self;
1194    #[inline]
1195    fn bitand(self, rhs: Self) -> Self {
1196        Self(self.0 & rhs.0)
1197    }
1198}
1199impl core::ops::BitAndAssign for AcquireProfilingLockFlagBitsKHR {
1200    #[inline]
1201    fn bitand_assign(&mut self, rhs: Self) {
1202        self.0 &= rhs.0;
1203    }
1204}
1205impl core::ops::BitXor for AcquireProfilingLockFlagBitsKHR {
1206    type Output = Self;
1207    #[inline]
1208    fn bitxor(self, rhs: Self) -> Self {
1209        Self(self.0 ^ rhs.0)
1210    }
1211}
1212impl core::ops::BitXorAssign for AcquireProfilingLockFlagBitsKHR {
1213    #[inline]
1214    fn bitxor_assign(&mut self, rhs: Self) {
1215        self.0 ^= rhs.0;
1216    }
1217}
1218impl core::ops::Not for AcquireProfilingLockFlagBitsKHR {
1219    type Output = Self;
1220    #[inline]
1221    fn not(self) -> Self {
1222        Self(!self.0)
1223    }
1224}
1225impl core::fmt::Debug for AcquireProfilingLockFlagBitsKHR {
1226    #[allow(unused_mut, unused_variables)]
1227    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1228        let mut first = true;
1229        let mut remaining = self.0;
1230        if remaining != 0u32 {
1231            if !first {
1232                f.write_str(" | ")?;
1233            }
1234            write!(f, "{:#x}", remaining)?;
1235        } else if first {
1236            f.write_str("(empty)")?;
1237        }
1238        Ok(())
1239    }
1240}
1241///[`VkAddressCommandFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCommandFlagBitsKHR.html)
1242#[repr(transparent)]
1243#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1244#[doc(alias = "VkAddressCommandFlagBitsKHR")]
1245pub struct AddressCommandFlagBitsKHR(u32);
1246impl AddressCommandFlagBitsKHR {
1247    #[inline]
1248    pub const fn empty() -> Self {
1249        Self(0u32)
1250    }
1251    #[inline]
1252    pub const fn from_raw(value: u32) -> Self {
1253        Self(value)
1254    }
1255    #[inline]
1256    pub const fn as_raw(self) -> u32 {
1257        self.0
1258    }
1259    #[inline]
1260    pub const fn is_empty(self) -> bool {
1261        self.0 == 0u32
1262    }
1263    #[inline]
1264    pub const fn contains(self, other: Self) -> bool {
1265        (self.0 & other.0) == other.0
1266    }
1267    #[inline]
1268    pub const fn all() -> Self {
1269        Self(63u32)
1270    }
1271    ///Bit 0.
1272    pub const PROTECTED: Self = Self(1u32);
1273    ///Bit 1.
1274    pub const FULLY_BOUND: Self = Self(2u32);
1275    ///Bit 2.
1276    pub const STORAGE_BUFFER_USAGE: Self = Self(4u32);
1277    ///Bit 3.
1278    pub const UNKNOWN_STORAGE_BUFFER_USAGE: Self = Self(8u32);
1279    ///Bit 4.
1280    pub const TRANSFORM_FEEDBACK_BUFFER_USAGE: Self = Self(16u32);
1281    ///Bit 5.
1282    pub const UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE: Self = Self(32u32);
1283}
1284impl core::ops::BitOr for AddressCommandFlagBitsKHR {
1285    type Output = Self;
1286    #[inline]
1287    fn bitor(self, rhs: Self) -> Self {
1288        Self(self.0 | rhs.0)
1289    }
1290}
1291impl core::ops::BitOrAssign for AddressCommandFlagBitsKHR {
1292    #[inline]
1293    fn bitor_assign(&mut self, rhs: Self) {
1294        self.0 |= rhs.0;
1295    }
1296}
1297impl core::ops::BitAnd for AddressCommandFlagBitsKHR {
1298    type Output = Self;
1299    #[inline]
1300    fn bitand(self, rhs: Self) -> Self {
1301        Self(self.0 & rhs.0)
1302    }
1303}
1304impl core::ops::BitAndAssign for AddressCommandFlagBitsKHR {
1305    #[inline]
1306    fn bitand_assign(&mut self, rhs: Self) {
1307        self.0 &= rhs.0;
1308    }
1309}
1310impl core::ops::BitXor for AddressCommandFlagBitsKHR {
1311    type Output = Self;
1312    #[inline]
1313    fn bitxor(self, rhs: Self) -> Self {
1314        Self(self.0 ^ rhs.0)
1315    }
1316}
1317impl core::ops::BitXorAssign for AddressCommandFlagBitsKHR {
1318    #[inline]
1319    fn bitxor_assign(&mut self, rhs: Self) {
1320        self.0 ^= rhs.0;
1321    }
1322}
1323impl core::ops::Not for AddressCommandFlagBitsKHR {
1324    type Output = Self;
1325    #[inline]
1326    fn not(self) -> Self {
1327        Self(!self.0)
1328    }
1329}
1330impl core::fmt::Debug for AddressCommandFlagBitsKHR {
1331    #[allow(unused_mut, unused_variables)]
1332    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1333        let mut first = true;
1334        let mut remaining = self.0;
1335        if remaining & Self::PROTECTED.0 != 0 {
1336            if !first {
1337                f.write_str(" | ")?;
1338            }
1339            f.write_str("PROTECTED")?;
1340            remaining &= !Self::PROTECTED.0;
1341            first = false;
1342        }
1343        if remaining & Self::FULLY_BOUND.0 != 0 {
1344            if !first {
1345                f.write_str(" | ")?;
1346            }
1347            f.write_str("FULLY_BOUND")?;
1348            remaining &= !Self::FULLY_BOUND.0;
1349            first = false;
1350        }
1351        if remaining & Self::STORAGE_BUFFER_USAGE.0 != 0 {
1352            if !first {
1353                f.write_str(" | ")?;
1354            }
1355            f.write_str("STORAGE_BUFFER_USAGE")?;
1356            remaining &= !Self::STORAGE_BUFFER_USAGE.0;
1357            first = false;
1358        }
1359        if remaining & Self::UNKNOWN_STORAGE_BUFFER_USAGE.0 != 0 {
1360            if !first {
1361                f.write_str(" | ")?;
1362            }
1363            f.write_str("UNKNOWN_STORAGE_BUFFER_USAGE")?;
1364            remaining &= !Self::UNKNOWN_STORAGE_BUFFER_USAGE.0;
1365            first = false;
1366        }
1367        if remaining & Self::TRANSFORM_FEEDBACK_BUFFER_USAGE.0 != 0 {
1368            if !first {
1369                f.write_str(" | ")?;
1370            }
1371            f.write_str("TRANSFORM_FEEDBACK_BUFFER_USAGE")?;
1372            remaining &= !Self::TRANSFORM_FEEDBACK_BUFFER_USAGE.0;
1373            first = false;
1374        }
1375        if remaining & Self::UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE.0 != 0 {
1376            if !first {
1377                f.write_str(" | ")?;
1378            }
1379            f.write_str("UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE")?;
1380            remaining &= !Self::UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE.0;
1381            first = false;
1382        }
1383        if remaining != 0u32 {
1384            if !first {
1385                f.write_str(" | ")?;
1386            }
1387            write!(f, "{:#x}", remaining)?;
1388        } else if first {
1389            f.write_str("(empty)")?;
1390        }
1391        Ok(())
1392    }
1393}
1394///[`VkAddressCopyFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCopyFlagBitsKHR.html)
1395#[repr(transparent)]
1396#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1397#[doc(alias = "VkAddressCopyFlagBitsKHR")]
1398pub struct AddressCopyFlagBitsKHR(u32);
1399impl AddressCopyFlagBitsKHR {
1400    #[inline]
1401    pub const fn empty() -> Self {
1402        Self(0u32)
1403    }
1404    #[inline]
1405    pub const fn from_raw(value: u32) -> Self {
1406        Self(value)
1407    }
1408    #[inline]
1409    pub const fn as_raw(self) -> u32 {
1410        self.0
1411    }
1412    #[inline]
1413    pub const fn is_empty(self) -> bool {
1414        self.0 == 0u32
1415    }
1416    #[inline]
1417    pub const fn contains(self, other: Self) -> bool {
1418        (self.0 & other.0) == other.0
1419    }
1420    #[inline]
1421    pub const fn all() -> Self {
1422        Self(7u32)
1423    }
1424    ///Bit 0.
1425    pub const DEVICE_LOCAL: Self = Self(1u32);
1426    ///Bit 1.
1427    pub const SPARSE: Self = Self(2u32);
1428    ///Bit 2.
1429    pub const PROTECTED: Self = Self(4u32);
1430}
1431impl core::ops::BitOr for AddressCopyFlagBitsKHR {
1432    type Output = Self;
1433    #[inline]
1434    fn bitor(self, rhs: Self) -> Self {
1435        Self(self.0 | rhs.0)
1436    }
1437}
1438impl core::ops::BitOrAssign for AddressCopyFlagBitsKHR {
1439    #[inline]
1440    fn bitor_assign(&mut self, rhs: Self) {
1441        self.0 |= rhs.0;
1442    }
1443}
1444impl core::ops::BitAnd for AddressCopyFlagBitsKHR {
1445    type Output = Self;
1446    #[inline]
1447    fn bitand(self, rhs: Self) -> Self {
1448        Self(self.0 & rhs.0)
1449    }
1450}
1451impl core::ops::BitAndAssign for AddressCopyFlagBitsKHR {
1452    #[inline]
1453    fn bitand_assign(&mut self, rhs: Self) {
1454        self.0 &= rhs.0;
1455    }
1456}
1457impl core::ops::BitXor for AddressCopyFlagBitsKHR {
1458    type Output = Self;
1459    #[inline]
1460    fn bitxor(self, rhs: Self) -> Self {
1461        Self(self.0 ^ rhs.0)
1462    }
1463}
1464impl core::ops::BitXorAssign for AddressCopyFlagBitsKHR {
1465    #[inline]
1466    fn bitxor_assign(&mut self, rhs: Self) {
1467        self.0 ^= rhs.0;
1468    }
1469}
1470impl core::ops::Not for AddressCopyFlagBitsKHR {
1471    type Output = Self;
1472    #[inline]
1473    fn not(self) -> Self {
1474        Self(!self.0)
1475    }
1476}
1477impl core::fmt::Debug for AddressCopyFlagBitsKHR {
1478    #[allow(unused_mut, unused_variables)]
1479    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1480        let mut first = true;
1481        let mut remaining = self.0;
1482        if remaining & Self::DEVICE_LOCAL.0 != 0 {
1483            if !first {
1484                f.write_str(" | ")?;
1485            }
1486            f.write_str("DEVICE_LOCAL")?;
1487            remaining &= !Self::DEVICE_LOCAL.0;
1488            first = false;
1489        }
1490        if remaining & Self::SPARSE.0 != 0 {
1491            if !first {
1492                f.write_str(" | ")?;
1493            }
1494            f.write_str("SPARSE")?;
1495            remaining &= !Self::SPARSE.0;
1496            first = false;
1497        }
1498        if remaining & Self::PROTECTED.0 != 0 {
1499            if !first {
1500                f.write_str(" | ")?;
1501            }
1502            f.write_str("PROTECTED")?;
1503            remaining &= !Self::PROTECTED.0;
1504            first = false;
1505        }
1506        if remaining != 0u32 {
1507            if !first {
1508                f.write_str(" | ")?;
1509            }
1510            write!(f, "{:#x}", remaining)?;
1511        } else if first {
1512            f.write_str("(empty)")?;
1513        }
1514        Ok(())
1515    }
1516}
1517///[`VkAttachmentDescriptionFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionFlagBits.html)
1518#[repr(transparent)]
1519#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1520#[doc(alias = "VkAttachmentDescriptionFlagBits")]
1521pub struct AttachmentDescriptionFlagBits(u32);
1522impl AttachmentDescriptionFlagBits {
1523    #[inline]
1524    pub const fn empty() -> Self {
1525        Self(0u32)
1526    }
1527    #[inline]
1528    pub const fn from_raw(value: u32) -> Self {
1529        Self(value)
1530    }
1531    #[inline]
1532    pub const fn as_raw(self) -> u32 {
1533        self.0
1534    }
1535    #[inline]
1536    pub const fn is_empty(self) -> bool {
1537        self.0 == 0u32
1538    }
1539    #[inline]
1540    pub const fn contains(self, other: Self) -> bool {
1541        (self.0 & other.0) == other.0
1542    }
1543    #[inline]
1544    pub const fn all() -> Self {
1545        Self(7u32)
1546    }
1547    ///Bit 0.
1548    pub const MAY_ALIAS: Self = Self(1u32);
1549    ///Bit 1.
1550    pub const RESOLVE_SKIP_TRANSFER_FUNCTION: Self = Self(2u32);
1551    ///Bit 2.
1552    pub const RESOLVE_ENABLE_TRANSFER_FUNCTION: Self = Self(4u32);
1553}
1554impl core::ops::BitOr for AttachmentDescriptionFlagBits {
1555    type Output = Self;
1556    #[inline]
1557    fn bitor(self, rhs: Self) -> Self {
1558        Self(self.0 | rhs.0)
1559    }
1560}
1561impl core::ops::BitOrAssign for AttachmentDescriptionFlagBits {
1562    #[inline]
1563    fn bitor_assign(&mut self, rhs: Self) {
1564        self.0 |= rhs.0;
1565    }
1566}
1567impl core::ops::BitAnd for AttachmentDescriptionFlagBits {
1568    type Output = Self;
1569    #[inline]
1570    fn bitand(self, rhs: Self) -> Self {
1571        Self(self.0 & rhs.0)
1572    }
1573}
1574impl core::ops::BitAndAssign for AttachmentDescriptionFlagBits {
1575    #[inline]
1576    fn bitand_assign(&mut self, rhs: Self) {
1577        self.0 &= rhs.0;
1578    }
1579}
1580impl core::ops::BitXor for AttachmentDescriptionFlagBits {
1581    type Output = Self;
1582    #[inline]
1583    fn bitxor(self, rhs: Self) -> Self {
1584        Self(self.0 ^ rhs.0)
1585    }
1586}
1587impl core::ops::BitXorAssign for AttachmentDescriptionFlagBits {
1588    #[inline]
1589    fn bitxor_assign(&mut self, rhs: Self) {
1590        self.0 ^= rhs.0;
1591    }
1592}
1593impl core::ops::Not for AttachmentDescriptionFlagBits {
1594    type Output = Self;
1595    #[inline]
1596    fn not(self) -> Self {
1597        Self(!self.0)
1598    }
1599}
1600impl core::fmt::Debug for AttachmentDescriptionFlagBits {
1601    #[allow(unused_mut, unused_variables)]
1602    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1603        let mut first = true;
1604        let mut remaining = self.0;
1605        if remaining & Self::MAY_ALIAS.0 != 0 {
1606            if !first {
1607                f.write_str(" | ")?;
1608            }
1609            f.write_str("MAY_ALIAS")?;
1610            remaining &= !Self::MAY_ALIAS.0;
1611            first = false;
1612        }
1613        if remaining & Self::RESOLVE_SKIP_TRANSFER_FUNCTION.0 != 0 {
1614            if !first {
1615                f.write_str(" | ")?;
1616            }
1617            f.write_str("RESOLVE_SKIP_TRANSFER_FUNCTION")?;
1618            remaining &= !Self::RESOLVE_SKIP_TRANSFER_FUNCTION.0;
1619            first = false;
1620        }
1621        if remaining & Self::RESOLVE_ENABLE_TRANSFER_FUNCTION.0 != 0 {
1622            if !first {
1623                f.write_str(" | ")?;
1624            }
1625            f.write_str("RESOLVE_ENABLE_TRANSFER_FUNCTION")?;
1626            remaining &= !Self::RESOLVE_ENABLE_TRANSFER_FUNCTION.0;
1627            first = false;
1628        }
1629        if remaining != 0u32 {
1630            if !first {
1631                f.write_str(" | ")?;
1632            }
1633            write!(f, "{:#x}", remaining)?;
1634        } else if first {
1635            f.write_str("(empty)")?;
1636        }
1637        Ok(())
1638    }
1639}
1640///[`VkBufferCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateFlagBits.html)
1641#[repr(transparent)]
1642#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1643#[doc(alias = "VkBufferCreateFlagBits")]
1644pub struct BufferCreateFlagBits(u32);
1645impl BufferCreateFlagBits {
1646    #[inline]
1647    pub const fn empty() -> Self {
1648        Self(0u32)
1649    }
1650    #[inline]
1651    pub const fn from_raw(value: u32) -> Self {
1652        Self(value)
1653    }
1654    #[inline]
1655    pub const fn as_raw(self) -> u32 {
1656        self.0
1657    }
1658    #[inline]
1659    pub const fn is_empty(self) -> bool {
1660        self.0 == 0u32
1661    }
1662    #[inline]
1663    pub const fn contains(self, other: Self) -> bool {
1664        (self.0 & other.0) == other.0
1665    }
1666    #[inline]
1667    pub const fn all() -> Self {
1668        Self(127u32)
1669    }
1670    ///Bit 0.
1671    pub const SPARSE_BINDING: Self = Self(1u32);
1672    ///Bit 1.
1673    pub const SPARSE_RESIDENCY: Self = Self(2u32);
1674    ///Bit 2.
1675    pub const SPARSE_ALIASED: Self = Self(4u32);
1676    ///Bit 3.
1677    pub const PROTECTED: Self = Self(8u32);
1678    ///Bit 4.
1679    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(16u32);
1680    ///Bit 5.
1681    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self(32u32);
1682    ///Bit 6.
1683    pub const VIDEO_PROFILE_INDEPENDENT: Self = Self(64u32);
1684}
1685impl core::ops::BitOr for BufferCreateFlagBits {
1686    type Output = Self;
1687    #[inline]
1688    fn bitor(self, rhs: Self) -> Self {
1689        Self(self.0 | rhs.0)
1690    }
1691}
1692impl core::ops::BitOrAssign for BufferCreateFlagBits {
1693    #[inline]
1694    fn bitor_assign(&mut self, rhs: Self) {
1695        self.0 |= rhs.0;
1696    }
1697}
1698impl core::ops::BitAnd for BufferCreateFlagBits {
1699    type Output = Self;
1700    #[inline]
1701    fn bitand(self, rhs: Self) -> Self {
1702        Self(self.0 & rhs.0)
1703    }
1704}
1705impl core::ops::BitAndAssign for BufferCreateFlagBits {
1706    #[inline]
1707    fn bitand_assign(&mut self, rhs: Self) {
1708        self.0 &= rhs.0;
1709    }
1710}
1711impl core::ops::BitXor for BufferCreateFlagBits {
1712    type Output = Self;
1713    #[inline]
1714    fn bitxor(self, rhs: Self) -> Self {
1715        Self(self.0 ^ rhs.0)
1716    }
1717}
1718impl core::ops::BitXorAssign for BufferCreateFlagBits {
1719    #[inline]
1720    fn bitxor_assign(&mut self, rhs: Self) {
1721        self.0 ^= rhs.0;
1722    }
1723}
1724impl core::ops::Not for BufferCreateFlagBits {
1725    type Output = Self;
1726    #[inline]
1727    fn not(self) -> Self {
1728        Self(!self.0)
1729    }
1730}
1731impl core::fmt::Debug for BufferCreateFlagBits {
1732    #[allow(unused_mut, unused_variables)]
1733    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1734        let mut first = true;
1735        let mut remaining = self.0;
1736        if remaining & Self::SPARSE_BINDING.0 != 0 {
1737            if !first {
1738                f.write_str(" | ")?;
1739            }
1740            f.write_str("SPARSE_BINDING")?;
1741            remaining &= !Self::SPARSE_BINDING.0;
1742            first = false;
1743        }
1744        if remaining & Self::SPARSE_RESIDENCY.0 != 0 {
1745            if !first {
1746                f.write_str(" | ")?;
1747            }
1748            f.write_str("SPARSE_RESIDENCY")?;
1749            remaining &= !Self::SPARSE_RESIDENCY.0;
1750            first = false;
1751        }
1752        if remaining & Self::SPARSE_ALIASED.0 != 0 {
1753            if !first {
1754                f.write_str(" | ")?;
1755            }
1756            f.write_str("SPARSE_ALIASED")?;
1757            remaining &= !Self::SPARSE_ALIASED.0;
1758            first = false;
1759        }
1760        if remaining & Self::PROTECTED.0 != 0 {
1761            if !first {
1762                f.write_str(" | ")?;
1763            }
1764            f.write_str("PROTECTED")?;
1765            remaining &= !Self::PROTECTED.0;
1766            first = false;
1767        }
1768        if remaining & Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0 != 0 {
1769            if !first {
1770                f.write_str(" | ")?;
1771            }
1772            f.write_str("DEVICE_ADDRESS_CAPTURE_REPLAY")?;
1773            remaining &= !Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0;
1774            first = false;
1775        }
1776        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0 != 0 {
1777            if !first {
1778                f.write_str(" | ")?;
1779            }
1780            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY")?;
1781            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0;
1782            first = false;
1783        }
1784        if remaining & Self::VIDEO_PROFILE_INDEPENDENT.0 != 0 {
1785            if !first {
1786                f.write_str(" | ")?;
1787            }
1788            f.write_str("VIDEO_PROFILE_INDEPENDENT")?;
1789            remaining &= !Self::VIDEO_PROFILE_INDEPENDENT.0;
1790            first = false;
1791        }
1792        if remaining != 0u32 {
1793            if !first {
1794                f.write_str(" | ")?;
1795            }
1796            write!(f, "{:#x}", remaining)?;
1797        } else if first {
1798            f.write_str("(empty)")?;
1799        }
1800        Ok(())
1801    }
1802}
1803///[`VkBufferUsageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits.html)
1804#[repr(transparent)]
1805#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1806#[doc(alias = "VkBufferUsageFlagBits")]
1807pub struct BufferUsageFlagBits(u32);
1808impl BufferUsageFlagBits {
1809    #[inline]
1810    pub const fn empty() -> Self {
1811        Self(0u32)
1812    }
1813    #[inline]
1814    pub const fn from_raw(value: u32) -> Self {
1815        Self(value)
1816    }
1817    #[inline]
1818    pub const fn as_raw(self) -> u32 {
1819        self.0
1820    }
1821    #[inline]
1822    pub const fn is_empty(self) -> bool {
1823        self.0 == 0u32
1824    }
1825    #[inline]
1826    pub const fn contains(self, other: Self) -> bool {
1827        (self.0 & other.0) == other.0
1828    }
1829    #[inline]
1830    pub const fn all() -> Self {
1831        Self(536608767u32)
1832    }
1833    ///Bit 0.
1834    pub const TRANSFER_SRC: Self = Self(1u32);
1835    ///Bit 1.
1836    pub const TRANSFER_DST: Self = Self(2u32);
1837    ///Bit 2.
1838    pub const UNIFORM_TEXEL_BUFFER: Self = Self(4u32);
1839    ///Bit 3.
1840    pub const STORAGE_TEXEL_BUFFER: Self = Self(8u32);
1841    ///Bit 4.
1842    pub const UNIFORM_BUFFER: Self = Self(16u32);
1843    ///Bit 5.
1844    pub const STORAGE_BUFFER: Self = Self(32u32);
1845    ///Bit 6.
1846    pub const INDEX_BUFFER: Self = Self(64u32);
1847    ///Bit 7.
1848    pub const VERTEX_BUFFER: Self = Self(128u32);
1849    ///Bit 8.
1850    pub const INDIRECT_BUFFER: Self = Self(256u32);
1851    ///Bit 17.
1852    pub const SHADER_DEVICE_ADDRESS: Self = Self(131072u32);
1853    ///Bit 13.
1854    pub const VIDEO_DECODE_SRC: Self = Self(8192u32);
1855    ///Bit 14.
1856    pub const VIDEO_DECODE_DST: Self = Self(16384u32);
1857    ///Bit 11.
1858    pub const TRANSFORM_FEEDBACK_BUFFER: Self = Self(2048u32);
1859    ///Bit 12.
1860    pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER: Self = Self(4096u32);
1861    ///Bit 9.
1862    pub const CONDITIONAL_RENDERING: Self = Self(512u32);
1863    ///Bit 25.
1864    pub const EXECUTION_GRAPH_SCRATCH_BIT: Self = Self(33554432u32);
1865    ///Bit 28.
1866    pub const DESCRIPTOR_HEAP: Self = Self(268435456u32);
1867    ///Bit 19.
1868    pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY: Self = Self(524288u32);
1869    ///Bit 20.
1870    pub const ACCELERATION_STRUCTURE_STORAGE: Self = Self(1048576u32);
1871    ///Bit 10.
1872    pub const SHADER_BINDING_TABLE: Self = Self(1024u32);
1873    pub const RAY_TRACING: Self = Self::SHADER_BINDING_TABLE;
1874    ///Bit 15.
1875    pub const VIDEO_ENCODE_DST: Self = Self(32768u32);
1876    ///Bit 16.
1877    pub const VIDEO_ENCODE_SRC: Self = Self(65536u32);
1878    ///Bit 21.
1879    pub const SAMPLER_DESCRIPTOR_BUFFER: Self = Self(2097152u32);
1880    ///Bit 22.
1881    pub const RESOURCE_DESCRIPTOR_BUFFER: Self = Self(4194304u32);
1882    ///Bit 26.
1883    pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER: Self = Self(67108864u32);
1884    ///Bit 23.
1885    pub const MICROMAP_BUILD_INPUT_READ_ONLY: Self = Self(8388608u32);
1886    ///Bit 24.
1887    pub const MICROMAP_STORAGE: Self = Self(16777216u32);
1888    ///Bit 27.
1889    pub const TILE_MEMORY_BIT: Self = Self(134217728u32);
1890}
1891impl core::ops::BitOr for BufferUsageFlagBits {
1892    type Output = Self;
1893    #[inline]
1894    fn bitor(self, rhs: Self) -> Self {
1895        Self(self.0 | rhs.0)
1896    }
1897}
1898impl core::ops::BitOrAssign for BufferUsageFlagBits {
1899    #[inline]
1900    fn bitor_assign(&mut self, rhs: Self) {
1901        self.0 |= rhs.0;
1902    }
1903}
1904impl core::ops::BitAnd for BufferUsageFlagBits {
1905    type Output = Self;
1906    #[inline]
1907    fn bitand(self, rhs: Self) -> Self {
1908        Self(self.0 & rhs.0)
1909    }
1910}
1911impl core::ops::BitAndAssign for BufferUsageFlagBits {
1912    #[inline]
1913    fn bitand_assign(&mut self, rhs: Self) {
1914        self.0 &= rhs.0;
1915    }
1916}
1917impl core::ops::BitXor for BufferUsageFlagBits {
1918    type Output = Self;
1919    #[inline]
1920    fn bitxor(self, rhs: Self) -> Self {
1921        Self(self.0 ^ rhs.0)
1922    }
1923}
1924impl core::ops::BitXorAssign for BufferUsageFlagBits {
1925    #[inline]
1926    fn bitxor_assign(&mut self, rhs: Self) {
1927        self.0 ^= rhs.0;
1928    }
1929}
1930impl core::ops::Not for BufferUsageFlagBits {
1931    type Output = Self;
1932    #[inline]
1933    fn not(self) -> Self {
1934        Self(!self.0)
1935    }
1936}
1937impl core::fmt::Debug for BufferUsageFlagBits {
1938    #[allow(unused_mut, unused_variables)]
1939    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1940        let mut first = true;
1941        let mut remaining = self.0;
1942        if remaining & Self::TRANSFER_SRC.0 != 0 {
1943            if !first {
1944                f.write_str(" | ")?;
1945            }
1946            f.write_str("TRANSFER_SRC")?;
1947            remaining &= !Self::TRANSFER_SRC.0;
1948            first = false;
1949        }
1950        if remaining & Self::TRANSFER_DST.0 != 0 {
1951            if !first {
1952                f.write_str(" | ")?;
1953            }
1954            f.write_str("TRANSFER_DST")?;
1955            remaining &= !Self::TRANSFER_DST.0;
1956            first = false;
1957        }
1958        if remaining & Self::UNIFORM_TEXEL_BUFFER.0 != 0 {
1959            if !first {
1960                f.write_str(" | ")?;
1961            }
1962            f.write_str("UNIFORM_TEXEL_BUFFER")?;
1963            remaining &= !Self::UNIFORM_TEXEL_BUFFER.0;
1964            first = false;
1965        }
1966        if remaining & Self::STORAGE_TEXEL_BUFFER.0 != 0 {
1967            if !first {
1968                f.write_str(" | ")?;
1969            }
1970            f.write_str("STORAGE_TEXEL_BUFFER")?;
1971            remaining &= !Self::STORAGE_TEXEL_BUFFER.0;
1972            first = false;
1973        }
1974        if remaining & Self::UNIFORM_BUFFER.0 != 0 {
1975            if !first {
1976                f.write_str(" | ")?;
1977            }
1978            f.write_str("UNIFORM_BUFFER")?;
1979            remaining &= !Self::UNIFORM_BUFFER.0;
1980            first = false;
1981        }
1982        if remaining & Self::STORAGE_BUFFER.0 != 0 {
1983            if !first {
1984                f.write_str(" | ")?;
1985            }
1986            f.write_str("STORAGE_BUFFER")?;
1987            remaining &= !Self::STORAGE_BUFFER.0;
1988            first = false;
1989        }
1990        if remaining & Self::INDEX_BUFFER.0 != 0 {
1991            if !first {
1992                f.write_str(" | ")?;
1993            }
1994            f.write_str("INDEX_BUFFER")?;
1995            remaining &= !Self::INDEX_BUFFER.0;
1996            first = false;
1997        }
1998        if remaining & Self::VERTEX_BUFFER.0 != 0 {
1999            if !first {
2000                f.write_str(" | ")?;
2001            }
2002            f.write_str("VERTEX_BUFFER")?;
2003            remaining &= !Self::VERTEX_BUFFER.0;
2004            first = false;
2005        }
2006        if remaining & Self::INDIRECT_BUFFER.0 != 0 {
2007            if !first {
2008                f.write_str(" | ")?;
2009            }
2010            f.write_str("INDIRECT_BUFFER")?;
2011            remaining &= !Self::INDIRECT_BUFFER.0;
2012            first = false;
2013        }
2014        if remaining & Self::SHADER_DEVICE_ADDRESS.0 != 0 {
2015            if !first {
2016                f.write_str(" | ")?;
2017            }
2018            f.write_str("SHADER_DEVICE_ADDRESS")?;
2019            remaining &= !Self::SHADER_DEVICE_ADDRESS.0;
2020            first = false;
2021        }
2022        if remaining & Self::VIDEO_DECODE_SRC.0 != 0 {
2023            if !first {
2024                f.write_str(" | ")?;
2025            }
2026            f.write_str("VIDEO_DECODE_SRC")?;
2027            remaining &= !Self::VIDEO_DECODE_SRC.0;
2028            first = false;
2029        }
2030        if remaining & Self::VIDEO_DECODE_DST.0 != 0 {
2031            if !first {
2032                f.write_str(" | ")?;
2033            }
2034            f.write_str("VIDEO_DECODE_DST")?;
2035            remaining &= !Self::VIDEO_DECODE_DST.0;
2036            first = false;
2037        }
2038        if remaining & Self::TRANSFORM_FEEDBACK_BUFFER.0 != 0 {
2039            if !first {
2040                f.write_str(" | ")?;
2041            }
2042            f.write_str("TRANSFORM_FEEDBACK_BUFFER")?;
2043            remaining &= !Self::TRANSFORM_FEEDBACK_BUFFER.0;
2044            first = false;
2045        }
2046        if remaining & Self::TRANSFORM_FEEDBACK_COUNTER_BUFFER.0 != 0 {
2047            if !first {
2048                f.write_str(" | ")?;
2049            }
2050            f.write_str("TRANSFORM_FEEDBACK_COUNTER_BUFFER")?;
2051            remaining &= !Self::TRANSFORM_FEEDBACK_COUNTER_BUFFER.0;
2052            first = false;
2053        }
2054        if remaining & Self::CONDITIONAL_RENDERING.0 != 0 {
2055            if !first {
2056                f.write_str(" | ")?;
2057            }
2058            f.write_str("CONDITIONAL_RENDERING")?;
2059            remaining &= !Self::CONDITIONAL_RENDERING.0;
2060            first = false;
2061        }
2062        if remaining & Self::EXECUTION_GRAPH_SCRATCH_BIT.0 != 0 {
2063            if !first {
2064                f.write_str(" | ")?;
2065            }
2066            f.write_str("EXECUTION_GRAPH_SCRATCH_BIT")?;
2067            remaining &= !Self::EXECUTION_GRAPH_SCRATCH_BIT.0;
2068            first = false;
2069        }
2070        if remaining & Self::DESCRIPTOR_HEAP.0 != 0 {
2071            if !first {
2072                f.write_str(" | ")?;
2073            }
2074            f.write_str("DESCRIPTOR_HEAP")?;
2075            remaining &= !Self::DESCRIPTOR_HEAP.0;
2076            first = false;
2077        }
2078        if remaining & Self::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0 != 0 {
2079            if !first {
2080                f.write_str(" | ")?;
2081            }
2082            f.write_str("ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY")?;
2083            remaining &= !Self::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0;
2084            first = false;
2085        }
2086        if remaining & Self::ACCELERATION_STRUCTURE_STORAGE.0 != 0 {
2087            if !first {
2088                f.write_str(" | ")?;
2089            }
2090            f.write_str("ACCELERATION_STRUCTURE_STORAGE")?;
2091            remaining &= !Self::ACCELERATION_STRUCTURE_STORAGE.0;
2092            first = false;
2093        }
2094        if remaining & Self::SHADER_BINDING_TABLE.0 != 0 {
2095            if !first {
2096                f.write_str(" | ")?;
2097            }
2098            f.write_str("SHADER_BINDING_TABLE")?;
2099            remaining &= !Self::SHADER_BINDING_TABLE.0;
2100            first = false;
2101        }
2102        if remaining & Self::VIDEO_ENCODE_DST.0 != 0 {
2103            if !first {
2104                f.write_str(" | ")?;
2105            }
2106            f.write_str("VIDEO_ENCODE_DST")?;
2107            remaining &= !Self::VIDEO_ENCODE_DST.0;
2108            first = false;
2109        }
2110        if remaining & Self::VIDEO_ENCODE_SRC.0 != 0 {
2111            if !first {
2112                f.write_str(" | ")?;
2113            }
2114            f.write_str("VIDEO_ENCODE_SRC")?;
2115            remaining &= !Self::VIDEO_ENCODE_SRC.0;
2116            first = false;
2117        }
2118        if remaining & Self::SAMPLER_DESCRIPTOR_BUFFER.0 != 0 {
2119            if !first {
2120                f.write_str(" | ")?;
2121            }
2122            f.write_str("SAMPLER_DESCRIPTOR_BUFFER")?;
2123            remaining &= !Self::SAMPLER_DESCRIPTOR_BUFFER.0;
2124            first = false;
2125        }
2126        if remaining & Self::RESOURCE_DESCRIPTOR_BUFFER.0 != 0 {
2127            if !first {
2128                f.write_str(" | ")?;
2129            }
2130            f.write_str("RESOURCE_DESCRIPTOR_BUFFER")?;
2131            remaining &= !Self::RESOURCE_DESCRIPTOR_BUFFER.0;
2132            first = false;
2133        }
2134        if remaining & Self::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0 != 0 {
2135            if !first {
2136                f.write_str(" | ")?;
2137            }
2138            f.write_str("PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER")?;
2139            remaining &= !Self::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0;
2140            first = false;
2141        }
2142        if remaining & Self::MICROMAP_BUILD_INPUT_READ_ONLY.0 != 0 {
2143            if !first {
2144                f.write_str(" | ")?;
2145            }
2146            f.write_str("MICROMAP_BUILD_INPUT_READ_ONLY")?;
2147            remaining &= !Self::MICROMAP_BUILD_INPUT_READ_ONLY.0;
2148            first = false;
2149        }
2150        if remaining & Self::MICROMAP_STORAGE.0 != 0 {
2151            if !first {
2152                f.write_str(" | ")?;
2153            }
2154            f.write_str("MICROMAP_STORAGE")?;
2155            remaining &= !Self::MICROMAP_STORAGE.0;
2156            first = false;
2157        }
2158        if remaining & Self::TILE_MEMORY_BIT.0 != 0 {
2159            if !first {
2160                f.write_str(" | ")?;
2161            }
2162            f.write_str("TILE_MEMORY_BIT")?;
2163            remaining &= !Self::TILE_MEMORY_BIT.0;
2164            first = false;
2165        }
2166        if remaining != 0u32 {
2167            if !first {
2168                f.write_str(" | ")?;
2169            }
2170            write!(f, "{:#x}", remaining)?;
2171        } else if first {
2172            f.write_str("(empty)")?;
2173        }
2174        Ok(())
2175    }
2176}
2177///[`VkBufferUsageFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits2.html)
2178#[repr(transparent)]
2179#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2180#[doc(alias = "VkBufferUsageFlagBits2")]
2181pub struct BufferUsageFlagBits2(u64);
2182impl BufferUsageFlagBits2 {
2183    #[inline]
2184    pub const fn empty() -> Self {
2185        Self(0u64)
2186    }
2187    #[inline]
2188    pub const fn from_raw(value: u64) -> Self {
2189        Self(value)
2190    }
2191    #[inline]
2192    pub const fn as_raw(self) -> u64 {
2193        self.0
2194    }
2195    #[inline]
2196    pub const fn is_empty(self) -> bool {
2197        self.0 == 0u64
2198    }
2199    #[inline]
2200    pub const fn contains(self, other: Self) -> bool {
2201        (self.0 & other.0) == other.0
2202    }
2203    #[inline]
2204    pub const fn all() -> Self {
2205        Self(16105865215u64)
2206    }
2207    ///Bit 0.
2208    pub const _2_TRANSFER_SRC: Self = Self(1u64);
2209    ///Bit 1.
2210    pub const _2_TRANSFER_DST: Self = Self(2u64);
2211    ///Bit 2.
2212    pub const _2_UNIFORM_TEXEL_BUFFER: Self = Self(4u64);
2213    ///Bit 3.
2214    pub const _2_STORAGE_TEXEL_BUFFER: Self = Self(8u64);
2215    ///Bit 4.
2216    pub const _2_UNIFORM_BUFFER: Self = Self(16u64);
2217    ///Bit 5.
2218    pub const _2_STORAGE_BUFFER: Self = Self(32u64);
2219    ///Bit 6.
2220    pub const _2_INDEX_BUFFER: Self = Self(64u64);
2221    ///Bit 7.
2222    pub const _2_VERTEX_BUFFER: Self = Self(128u64);
2223    ///Bit 8.
2224    pub const _2_INDIRECT_BUFFER: Self = Self(256u64);
2225    ///Bit 17.
2226    pub const _2_SHADER_DEVICE_ADDRESS: Self = Self(131072u64);
2227    ///Bit 25.
2228    pub const _2_EXECUTION_GRAPH_SCRATCH_BIT: Self = Self(33554432u64);
2229    ///Bit 28.
2230    pub const _2_DESCRIPTOR_HEAP: Self = Self(268435456u64);
2231    ///Bit 9.
2232    pub const _2_CONDITIONAL_RENDERING: Self = Self(512u64);
2233    ///Bit 10.
2234    pub const _2_SHADER_BINDING_TABLE: Self = Self(1024u64);
2235    pub const _2_RAY_TRACING: Self = Self::_2_SHADER_BINDING_TABLE;
2236    ///Bit 11.
2237    pub const _2_TRANSFORM_FEEDBACK_BUFFER: Self = Self(2048u64);
2238    ///Bit 12.
2239    pub const _2_TRANSFORM_FEEDBACK_COUNTER_BUFFER: Self = Self(4096u64);
2240    ///Bit 13.
2241    pub const _2_VIDEO_DECODE_SRC: Self = Self(8192u64);
2242    ///Bit 14.
2243    pub const _2_VIDEO_DECODE_DST: Self = Self(16384u64);
2244    ///Bit 15.
2245    pub const _2_VIDEO_ENCODE_DST: Self = Self(32768u64);
2246    ///Bit 16.
2247    pub const _2_VIDEO_ENCODE_SRC: Self = Self(65536u64);
2248    ///Bit 19.
2249    pub const _2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY: Self = Self(524288u64);
2250    ///Bit 20.
2251    pub const _2_ACCELERATION_STRUCTURE_STORAGE: Self = Self(1048576u64);
2252    ///Bit 21.
2253    pub const _2_SAMPLER_DESCRIPTOR_BUFFER: Self = Self(2097152u64);
2254    ///Bit 22.
2255    pub const _2_RESOURCE_DESCRIPTOR_BUFFER: Self = Self(4194304u64);
2256    ///Bit 26.
2257    pub const _2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER: Self = Self(67108864u64);
2258    ///Bit 23.
2259    pub const _2_MICROMAP_BUILD_INPUT_READ_ONLY: Self = Self(8388608u64);
2260    ///Bit 24.
2261    pub const _2_MICROMAP_STORAGE: Self = Self(16777216u64);
2262    ///Bit 33.
2263    pub const _2_COMPRESSED_DATA_DGF1_BIT: Self = Self(8589934592u64);
2264    ///Bit 29.
2265    pub const _2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT: Self = Self(536870912u64);
2266    ///Bit 27.
2267    pub const _2_TILE_MEMORY_BIT: Self = Self(134217728u64);
2268    ///Bit 32.
2269    pub const _2_MEMORY_DECOMPRESSION: Self = Self(4294967296u64);
2270    ///Bit 31.
2271    pub const _2_PREPROCESS_BUFFER: Self = Self(2147483648u64);
2272}
2273impl core::ops::BitOr for BufferUsageFlagBits2 {
2274    type Output = Self;
2275    #[inline]
2276    fn bitor(self, rhs: Self) -> Self {
2277        Self(self.0 | rhs.0)
2278    }
2279}
2280impl core::ops::BitOrAssign for BufferUsageFlagBits2 {
2281    #[inline]
2282    fn bitor_assign(&mut self, rhs: Self) {
2283        self.0 |= rhs.0;
2284    }
2285}
2286impl core::ops::BitAnd for BufferUsageFlagBits2 {
2287    type Output = Self;
2288    #[inline]
2289    fn bitand(self, rhs: Self) -> Self {
2290        Self(self.0 & rhs.0)
2291    }
2292}
2293impl core::ops::BitAndAssign for BufferUsageFlagBits2 {
2294    #[inline]
2295    fn bitand_assign(&mut self, rhs: Self) {
2296        self.0 &= rhs.0;
2297    }
2298}
2299impl core::ops::BitXor for BufferUsageFlagBits2 {
2300    type Output = Self;
2301    #[inline]
2302    fn bitxor(self, rhs: Self) -> Self {
2303        Self(self.0 ^ rhs.0)
2304    }
2305}
2306impl core::ops::BitXorAssign for BufferUsageFlagBits2 {
2307    #[inline]
2308    fn bitxor_assign(&mut self, rhs: Self) {
2309        self.0 ^= rhs.0;
2310    }
2311}
2312impl core::ops::Not for BufferUsageFlagBits2 {
2313    type Output = Self;
2314    #[inline]
2315    fn not(self) -> Self {
2316        Self(!self.0)
2317    }
2318}
2319impl core::fmt::Debug for BufferUsageFlagBits2 {
2320    #[allow(unused_mut, unused_variables)]
2321    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2322        let mut first = true;
2323        let mut remaining = self.0;
2324        if remaining & Self::_2_TRANSFER_SRC.0 != 0 {
2325            if !first {
2326                f.write_str(" | ")?;
2327            }
2328            f.write_str("_2_TRANSFER_SRC")?;
2329            remaining &= !Self::_2_TRANSFER_SRC.0;
2330            first = false;
2331        }
2332        if remaining & Self::_2_TRANSFER_DST.0 != 0 {
2333            if !first {
2334                f.write_str(" | ")?;
2335            }
2336            f.write_str("_2_TRANSFER_DST")?;
2337            remaining &= !Self::_2_TRANSFER_DST.0;
2338            first = false;
2339        }
2340        if remaining & Self::_2_UNIFORM_TEXEL_BUFFER.0 != 0 {
2341            if !first {
2342                f.write_str(" | ")?;
2343            }
2344            f.write_str("_2_UNIFORM_TEXEL_BUFFER")?;
2345            remaining &= !Self::_2_UNIFORM_TEXEL_BUFFER.0;
2346            first = false;
2347        }
2348        if remaining & Self::_2_STORAGE_TEXEL_BUFFER.0 != 0 {
2349            if !first {
2350                f.write_str(" | ")?;
2351            }
2352            f.write_str("_2_STORAGE_TEXEL_BUFFER")?;
2353            remaining &= !Self::_2_STORAGE_TEXEL_BUFFER.0;
2354            first = false;
2355        }
2356        if remaining & Self::_2_UNIFORM_BUFFER.0 != 0 {
2357            if !first {
2358                f.write_str(" | ")?;
2359            }
2360            f.write_str("_2_UNIFORM_BUFFER")?;
2361            remaining &= !Self::_2_UNIFORM_BUFFER.0;
2362            first = false;
2363        }
2364        if remaining & Self::_2_STORAGE_BUFFER.0 != 0 {
2365            if !first {
2366                f.write_str(" | ")?;
2367            }
2368            f.write_str("_2_STORAGE_BUFFER")?;
2369            remaining &= !Self::_2_STORAGE_BUFFER.0;
2370            first = false;
2371        }
2372        if remaining & Self::_2_INDEX_BUFFER.0 != 0 {
2373            if !first {
2374                f.write_str(" | ")?;
2375            }
2376            f.write_str("_2_INDEX_BUFFER")?;
2377            remaining &= !Self::_2_INDEX_BUFFER.0;
2378            first = false;
2379        }
2380        if remaining & Self::_2_VERTEX_BUFFER.0 != 0 {
2381            if !first {
2382                f.write_str(" | ")?;
2383            }
2384            f.write_str("_2_VERTEX_BUFFER")?;
2385            remaining &= !Self::_2_VERTEX_BUFFER.0;
2386            first = false;
2387        }
2388        if remaining & Self::_2_INDIRECT_BUFFER.0 != 0 {
2389            if !first {
2390                f.write_str(" | ")?;
2391            }
2392            f.write_str("_2_INDIRECT_BUFFER")?;
2393            remaining &= !Self::_2_INDIRECT_BUFFER.0;
2394            first = false;
2395        }
2396        if remaining & Self::_2_SHADER_DEVICE_ADDRESS.0 != 0 {
2397            if !first {
2398                f.write_str(" | ")?;
2399            }
2400            f.write_str("_2_SHADER_DEVICE_ADDRESS")?;
2401            remaining &= !Self::_2_SHADER_DEVICE_ADDRESS.0;
2402            first = false;
2403        }
2404        if remaining & Self::_2_EXECUTION_GRAPH_SCRATCH_BIT.0 != 0 {
2405            if !first {
2406                f.write_str(" | ")?;
2407            }
2408            f.write_str("_2_EXECUTION_GRAPH_SCRATCH_BIT")?;
2409            remaining &= !Self::_2_EXECUTION_GRAPH_SCRATCH_BIT.0;
2410            first = false;
2411        }
2412        if remaining & Self::_2_DESCRIPTOR_HEAP.0 != 0 {
2413            if !first {
2414                f.write_str(" | ")?;
2415            }
2416            f.write_str("_2_DESCRIPTOR_HEAP")?;
2417            remaining &= !Self::_2_DESCRIPTOR_HEAP.0;
2418            first = false;
2419        }
2420        if remaining & Self::_2_CONDITIONAL_RENDERING.0 != 0 {
2421            if !first {
2422                f.write_str(" | ")?;
2423            }
2424            f.write_str("_2_CONDITIONAL_RENDERING")?;
2425            remaining &= !Self::_2_CONDITIONAL_RENDERING.0;
2426            first = false;
2427        }
2428        if remaining & Self::_2_SHADER_BINDING_TABLE.0 != 0 {
2429            if !first {
2430                f.write_str(" | ")?;
2431            }
2432            f.write_str("_2_SHADER_BINDING_TABLE")?;
2433            remaining &= !Self::_2_SHADER_BINDING_TABLE.0;
2434            first = false;
2435        }
2436        if remaining & Self::_2_TRANSFORM_FEEDBACK_BUFFER.0 != 0 {
2437            if !first {
2438                f.write_str(" | ")?;
2439            }
2440            f.write_str("_2_TRANSFORM_FEEDBACK_BUFFER")?;
2441            remaining &= !Self::_2_TRANSFORM_FEEDBACK_BUFFER.0;
2442            first = false;
2443        }
2444        if remaining & Self::_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER.0 != 0 {
2445            if !first {
2446                f.write_str(" | ")?;
2447            }
2448            f.write_str("_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER")?;
2449            remaining &= !Self::_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER.0;
2450            first = false;
2451        }
2452        if remaining & Self::_2_VIDEO_DECODE_SRC.0 != 0 {
2453            if !first {
2454                f.write_str(" | ")?;
2455            }
2456            f.write_str("_2_VIDEO_DECODE_SRC")?;
2457            remaining &= !Self::_2_VIDEO_DECODE_SRC.0;
2458            first = false;
2459        }
2460        if remaining & Self::_2_VIDEO_DECODE_DST.0 != 0 {
2461            if !first {
2462                f.write_str(" | ")?;
2463            }
2464            f.write_str("_2_VIDEO_DECODE_DST")?;
2465            remaining &= !Self::_2_VIDEO_DECODE_DST.0;
2466            first = false;
2467        }
2468        if remaining & Self::_2_VIDEO_ENCODE_DST.0 != 0 {
2469            if !first {
2470                f.write_str(" | ")?;
2471            }
2472            f.write_str("_2_VIDEO_ENCODE_DST")?;
2473            remaining &= !Self::_2_VIDEO_ENCODE_DST.0;
2474            first = false;
2475        }
2476        if remaining & Self::_2_VIDEO_ENCODE_SRC.0 != 0 {
2477            if !first {
2478                f.write_str(" | ")?;
2479            }
2480            f.write_str("_2_VIDEO_ENCODE_SRC")?;
2481            remaining &= !Self::_2_VIDEO_ENCODE_SRC.0;
2482            first = false;
2483        }
2484        if remaining & Self::_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0 != 0 {
2485            if !first {
2486                f.write_str(" | ")?;
2487            }
2488            f.write_str("_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY")?;
2489            remaining &= !Self::_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0;
2490            first = false;
2491        }
2492        if remaining & Self::_2_ACCELERATION_STRUCTURE_STORAGE.0 != 0 {
2493            if !first {
2494                f.write_str(" | ")?;
2495            }
2496            f.write_str("_2_ACCELERATION_STRUCTURE_STORAGE")?;
2497            remaining &= !Self::_2_ACCELERATION_STRUCTURE_STORAGE.0;
2498            first = false;
2499        }
2500        if remaining & Self::_2_SAMPLER_DESCRIPTOR_BUFFER.0 != 0 {
2501            if !first {
2502                f.write_str(" | ")?;
2503            }
2504            f.write_str("_2_SAMPLER_DESCRIPTOR_BUFFER")?;
2505            remaining &= !Self::_2_SAMPLER_DESCRIPTOR_BUFFER.0;
2506            first = false;
2507        }
2508        if remaining & Self::_2_RESOURCE_DESCRIPTOR_BUFFER.0 != 0 {
2509            if !first {
2510                f.write_str(" | ")?;
2511            }
2512            f.write_str("_2_RESOURCE_DESCRIPTOR_BUFFER")?;
2513            remaining &= !Self::_2_RESOURCE_DESCRIPTOR_BUFFER.0;
2514            first = false;
2515        }
2516        if remaining & Self::_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0 != 0 {
2517            if !first {
2518                f.write_str(" | ")?;
2519            }
2520            f.write_str("_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER")?;
2521            remaining &= !Self::_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0;
2522            first = false;
2523        }
2524        if remaining & Self::_2_MICROMAP_BUILD_INPUT_READ_ONLY.0 != 0 {
2525            if !first {
2526                f.write_str(" | ")?;
2527            }
2528            f.write_str("_2_MICROMAP_BUILD_INPUT_READ_ONLY")?;
2529            remaining &= !Self::_2_MICROMAP_BUILD_INPUT_READ_ONLY.0;
2530            first = false;
2531        }
2532        if remaining & Self::_2_MICROMAP_STORAGE.0 != 0 {
2533            if !first {
2534                f.write_str(" | ")?;
2535            }
2536            f.write_str("_2_MICROMAP_STORAGE")?;
2537            remaining &= !Self::_2_MICROMAP_STORAGE.0;
2538            first = false;
2539        }
2540        if remaining & Self::_2_COMPRESSED_DATA_DGF1_BIT.0 != 0 {
2541            if !first {
2542                f.write_str(" | ")?;
2543            }
2544            f.write_str("_2_COMPRESSED_DATA_DGF1_BIT")?;
2545            remaining &= !Self::_2_COMPRESSED_DATA_DGF1_BIT.0;
2546            first = false;
2547        }
2548        if remaining & Self::_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT.0 != 0 {
2549            if !first {
2550                f.write_str(" | ")?;
2551            }
2552            f.write_str("_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT")?;
2553            remaining &= !Self::_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT.0;
2554            first = false;
2555        }
2556        if remaining & Self::_2_TILE_MEMORY_BIT.0 != 0 {
2557            if !first {
2558                f.write_str(" | ")?;
2559            }
2560            f.write_str("_2_TILE_MEMORY_BIT")?;
2561            remaining &= !Self::_2_TILE_MEMORY_BIT.0;
2562            first = false;
2563        }
2564        if remaining & Self::_2_MEMORY_DECOMPRESSION.0 != 0 {
2565            if !first {
2566                f.write_str(" | ")?;
2567            }
2568            f.write_str("_2_MEMORY_DECOMPRESSION")?;
2569            remaining &= !Self::_2_MEMORY_DECOMPRESSION.0;
2570            first = false;
2571        }
2572        if remaining & Self::_2_PREPROCESS_BUFFER.0 != 0 {
2573            if !first {
2574                f.write_str(" | ")?;
2575            }
2576            f.write_str("_2_PREPROCESS_BUFFER")?;
2577            remaining &= !Self::_2_PREPROCESS_BUFFER.0;
2578            first = false;
2579        }
2580        if remaining != 0u64 {
2581            if !first {
2582                f.write_str(" | ")?;
2583            }
2584            write!(f, "{:#x}", remaining)?;
2585        } else if first {
2586            f.write_str("(empty)")?;
2587        }
2588        Ok(())
2589    }
2590}
2591///[`VkBuildAccelerationStructureFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureFlagBitsKHR.html)
2592#[repr(transparent)]
2593#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2594#[doc(alias = "VkBuildAccelerationStructureFlagBitsKHR")]
2595pub struct BuildAccelerationStructureFlagBitsKHR(u32);
2596impl BuildAccelerationStructureFlagBitsKHR {
2597    #[inline]
2598    pub const fn empty() -> Self {
2599        Self(0u32)
2600    }
2601    #[inline]
2602    pub const fn from_raw(value: u32) -> Self {
2603        Self(value)
2604    }
2605    #[inline]
2606    pub const fn as_raw(self) -> u32 {
2607        self.0
2608    }
2609    #[inline]
2610    pub const fn is_empty(self) -> bool {
2611        self.0 == 0u32
2612    }
2613    #[inline]
2614    pub const fn contains(self, other: Self) -> bool {
2615        (self.0 & other.0) == other.0
2616    }
2617    #[inline]
2618    pub const fn all() -> Self {
2619        Self(7167u32)
2620    }
2621    ///Bit 0.
2622    pub const ALLOW_UPDATE: Self = Self(1u32);
2623    ///Bit 1.
2624    pub const ALLOW_COMPACTION: Self = Self(2u32);
2625    ///Bit 2.
2626    pub const PREFER_FAST_TRACE: Self = Self(4u32);
2627    ///Bit 3.
2628    pub const PREFER_FAST_BUILD: Self = Self(8u32);
2629    ///Bit 4.
2630    pub const LOW_MEMORY: Self = Self(16u32);
2631    ///Bit 5.
2632    pub const MOTION: Self = Self(32u32);
2633    ///Bit 6.
2634    pub const ALLOW_OPACITY_MICROMAP_UPDATE: Self = Self(64u32);
2635    ///Bit 7.
2636    pub const ALLOW_DISABLE_OPACITY_MICROMAPS: Self = Self(128u32);
2637    ///Bit 8.
2638    pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE: Self = Self(256u32);
2639    ///Bit 9.
2640    pub const ALLOW_DISPLACEMENT_MICROMAP_UPDATE: Self = Self(512u32);
2641    ///Bit 11.
2642    pub const ALLOW_DATA_ACCESS: Self = Self(2048u32);
2643    ///Bit 12.
2644    pub const ALLOW_CLUSTER_OPACITY_MICROMAPS: Self = Self(4096u32);
2645}
2646impl core::ops::BitOr for BuildAccelerationStructureFlagBitsKHR {
2647    type Output = Self;
2648    #[inline]
2649    fn bitor(self, rhs: Self) -> Self {
2650        Self(self.0 | rhs.0)
2651    }
2652}
2653impl core::ops::BitOrAssign for BuildAccelerationStructureFlagBitsKHR {
2654    #[inline]
2655    fn bitor_assign(&mut self, rhs: Self) {
2656        self.0 |= rhs.0;
2657    }
2658}
2659impl core::ops::BitAnd for BuildAccelerationStructureFlagBitsKHR {
2660    type Output = Self;
2661    #[inline]
2662    fn bitand(self, rhs: Self) -> Self {
2663        Self(self.0 & rhs.0)
2664    }
2665}
2666impl core::ops::BitAndAssign for BuildAccelerationStructureFlagBitsKHR {
2667    #[inline]
2668    fn bitand_assign(&mut self, rhs: Self) {
2669        self.0 &= rhs.0;
2670    }
2671}
2672impl core::ops::BitXor for BuildAccelerationStructureFlagBitsKHR {
2673    type Output = Self;
2674    #[inline]
2675    fn bitxor(self, rhs: Self) -> Self {
2676        Self(self.0 ^ rhs.0)
2677    }
2678}
2679impl core::ops::BitXorAssign for BuildAccelerationStructureFlagBitsKHR {
2680    #[inline]
2681    fn bitxor_assign(&mut self, rhs: Self) {
2682        self.0 ^= rhs.0;
2683    }
2684}
2685impl core::ops::Not for BuildAccelerationStructureFlagBitsKHR {
2686    type Output = Self;
2687    #[inline]
2688    fn not(self) -> Self {
2689        Self(!self.0)
2690    }
2691}
2692impl core::fmt::Debug for BuildAccelerationStructureFlagBitsKHR {
2693    #[allow(unused_mut, unused_variables)]
2694    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2695        let mut first = true;
2696        let mut remaining = self.0;
2697        if remaining & Self::ALLOW_UPDATE.0 != 0 {
2698            if !first {
2699                f.write_str(" | ")?;
2700            }
2701            f.write_str("ALLOW_UPDATE")?;
2702            remaining &= !Self::ALLOW_UPDATE.0;
2703            first = false;
2704        }
2705        if remaining & Self::ALLOW_COMPACTION.0 != 0 {
2706            if !first {
2707                f.write_str(" | ")?;
2708            }
2709            f.write_str("ALLOW_COMPACTION")?;
2710            remaining &= !Self::ALLOW_COMPACTION.0;
2711            first = false;
2712        }
2713        if remaining & Self::PREFER_FAST_TRACE.0 != 0 {
2714            if !first {
2715                f.write_str(" | ")?;
2716            }
2717            f.write_str("PREFER_FAST_TRACE")?;
2718            remaining &= !Self::PREFER_FAST_TRACE.0;
2719            first = false;
2720        }
2721        if remaining & Self::PREFER_FAST_BUILD.0 != 0 {
2722            if !first {
2723                f.write_str(" | ")?;
2724            }
2725            f.write_str("PREFER_FAST_BUILD")?;
2726            remaining &= !Self::PREFER_FAST_BUILD.0;
2727            first = false;
2728        }
2729        if remaining & Self::LOW_MEMORY.0 != 0 {
2730            if !first {
2731                f.write_str(" | ")?;
2732            }
2733            f.write_str("LOW_MEMORY")?;
2734            remaining &= !Self::LOW_MEMORY.0;
2735            first = false;
2736        }
2737        if remaining & Self::MOTION.0 != 0 {
2738            if !first {
2739                f.write_str(" | ")?;
2740            }
2741            f.write_str("MOTION")?;
2742            remaining &= !Self::MOTION.0;
2743            first = false;
2744        }
2745        if remaining & Self::ALLOW_OPACITY_MICROMAP_UPDATE.0 != 0 {
2746            if !first {
2747                f.write_str(" | ")?;
2748            }
2749            f.write_str("ALLOW_OPACITY_MICROMAP_UPDATE")?;
2750            remaining &= !Self::ALLOW_OPACITY_MICROMAP_UPDATE.0;
2751            first = false;
2752        }
2753        if remaining & Self::ALLOW_DISABLE_OPACITY_MICROMAPS.0 != 0 {
2754            if !first {
2755                f.write_str(" | ")?;
2756            }
2757            f.write_str("ALLOW_DISABLE_OPACITY_MICROMAPS")?;
2758            remaining &= !Self::ALLOW_DISABLE_OPACITY_MICROMAPS.0;
2759            first = false;
2760        }
2761        if remaining & Self::ALLOW_OPACITY_MICROMAP_DATA_UPDATE.0 != 0 {
2762            if !first {
2763                f.write_str(" | ")?;
2764            }
2765            f.write_str("ALLOW_OPACITY_MICROMAP_DATA_UPDATE")?;
2766            remaining &= !Self::ALLOW_OPACITY_MICROMAP_DATA_UPDATE.0;
2767            first = false;
2768        }
2769        if remaining & Self::ALLOW_DISPLACEMENT_MICROMAP_UPDATE.0 != 0 {
2770            if !first {
2771                f.write_str(" | ")?;
2772            }
2773            f.write_str("ALLOW_DISPLACEMENT_MICROMAP_UPDATE")?;
2774            remaining &= !Self::ALLOW_DISPLACEMENT_MICROMAP_UPDATE.0;
2775            first = false;
2776        }
2777        if remaining & Self::ALLOW_DATA_ACCESS.0 != 0 {
2778            if !first {
2779                f.write_str(" | ")?;
2780            }
2781            f.write_str("ALLOW_DATA_ACCESS")?;
2782            remaining &= !Self::ALLOW_DATA_ACCESS.0;
2783            first = false;
2784        }
2785        if remaining & Self::ALLOW_CLUSTER_OPACITY_MICROMAPS.0 != 0 {
2786            if !first {
2787                f.write_str(" | ")?;
2788            }
2789            f.write_str("ALLOW_CLUSTER_OPACITY_MICROMAPS")?;
2790            remaining &= !Self::ALLOW_CLUSTER_OPACITY_MICROMAPS.0;
2791            first = false;
2792        }
2793        if remaining != 0u32 {
2794            if !first {
2795                f.write_str(" | ")?;
2796            }
2797            write!(f, "{:#x}", remaining)?;
2798        } else if first {
2799            f.write_str("(empty)")?;
2800        }
2801        Ok(())
2802    }
2803}
2804///[`VkBuildMicromapFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapFlagBitsEXT.html)
2805#[repr(transparent)]
2806#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2807#[doc(alias = "VkBuildMicromapFlagBitsEXT")]
2808pub struct BuildMicromapFlagBitsEXT(u32);
2809impl BuildMicromapFlagBitsEXT {
2810    #[inline]
2811    pub const fn empty() -> Self {
2812        Self(0u32)
2813    }
2814    #[inline]
2815    pub const fn from_raw(value: u32) -> Self {
2816        Self(value)
2817    }
2818    #[inline]
2819    pub const fn as_raw(self) -> u32 {
2820        self.0
2821    }
2822    #[inline]
2823    pub const fn is_empty(self) -> bool {
2824        self.0 == 0u32
2825    }
2826    #[inline]
2827    pub const fn contains(self, other: Self) -> bool {
2828        (self.0 & other.0) == other.0
2829    }
2830    #[inline]
2831    pub const fn all() -> Self {
2832        Self(7u32)
2833    }
2834    ///Bit 0.
2835    pub const PREFER_FAST_TRACE: Self = Self(1u32);
2836    ///Bit 1.
2837    pub const PREFER_FAST_BUILD: Self = Self(2u32);
2838    ///Bit 2.
2839    pub const ALLOW_COMPACTION: Self = Self(4u32);
2840}
2841impl core::ops::BitOr for BuildMicromapFlagBitsEXT {
2842    type Output = Self;
2843    #[inline]
2844    fn bitor(self, rhs: Self) -> Self {
2845        Self(self.0 | rhs.0)
2846    }
2847}
2848impl core::ops::BitOrAssign for BuildMicromapFlagBitsEXT {
2849    #[inline]
2850    fn bitor_assign(&mut self, rhs: Self) {
2851        self.0 |= rhs.0;
2852    }
2853}
2854impl core::ops::BitAnd for BuildMicromapFlagBitsEXT {
2855    type Output = Self;
2856    #[inline]
2857    fn bitand(self, rhs: Self) -> Self {
2858        Self(self.0 & rhs.0)
2859    }
2860}
2861impl core::ops::BitAndAssign for BuildMicromapFlagBitsEXT {
2862    #[inline]
2863    fn bitand_assign(&mut self, rhs: Self) {
2864        self.0 &= rhs.0;
2865    }
2866}
2867impl core::ops::BitXor for BuildMicromapFlagBitsEXT {
2868    type Output = Self;
2869    #[inline]
2870    fn bitxor(self, rhs: Self) -> Self {
2871        Self(self.0 ^ rhs.0)
2872    }
2873}
2874impl core::ops::BitXorAssign for BuildMicromapFlagBitsEXT {
2875    #[inline]
2876    fn bitxor_assign(&mut self, rhs: Self) {
2877        self.0 ^= rhs.0;
2878    }
2879}
2880impl core::ops::Not for BuildMicromapFlagBitsEXT {
2881    type Output = Self;
2882    #[inline]
2883    fn not(self) -> Self {
2884        Self(!self.0)
2885    }
2886}
2887impl core::fmt::Debug for BuildMicromapFlagBitsEXT {
2888    #[allow(unused_mut, unused_variables)]
2889    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2890        let mut first = true;
2891        let mut remaining = self.0;
2892        if remaining & Self::PREFER_FAST_TRACE.0 != 0 {
2893            if !first {
2894                f.write_str(" | ")?;
2895            }
2896            f.write_str("PREFER_FAST_TRACE")?;
2897            remaining &= !Self::PREFER_FAST_TRACE.0;
2898            first = false;
2899        }
2900        if remaining & Self::PREFER_FAST_BUILD.0 != 0 {
2901            if !first {
2902                f.write_str(" | ")?;
2903            }
2904            f.write_str("PREFER_FAST_BUILD")?;
2905            remaining &= !Self::PREFER_FAST_BUILD.0;
2906            first = false;
2907        }
2908        if remaining & Self::ALLOW_COMPACTION.0 != 0 {
2909            if !first {
2910                f.write_str(" | ")?;
2911            }
2912            f.write_str("ALLOW_COMPACTION")?;
2913            remaining &= !Self::ALLOW_COMPACTION.0;
2914            first = false;
2915        }
2916        if remaining != 0u32 {
2917            if !first {
2918                f.write_str(" | ")?;
2919            }
2920            write!(f, "{:#x}", remaining)?;
2921        } else if first {
2922            f.write_str("(empty)")?;
2923        }
2924        Ok(())
2925    }
2926}
2927///[`VkClusterAccelerationStructureAddressResolutionFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureAddressResolutionFlagBitsNV.html)
2928#[repr(transparent)]
2929#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2930#[doc(alias = "VkClusterAccelerationStructureAddressResolutionFlagBitsNV")]
2931pub struct ClusterAccelerationStructureAddressResolutionFlagBitsNV(u32);
2932impl ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2933    #[inline]
2934    pub const fn empty() -> Self {
2935        Self(0u32)
2936    }
2937    #[inline]
2938    pub const fn from_raw(value: u32) -> Self {
2939        Self(value)
2940    }
2941    #[inline]
2942    pub const fn as_raw(self) -> u32 {
2943        self.0
2944    }
2945    #[inline]
2946    pub const fn is_empty(self) -> bool {
2947        self.0 == 0u32
2948    }
2949    #[inline]
2950    pub const fn contains(self, other: Self) -> bool {
2951        (self.0 & other.0) == other.0
2952    }
2953    #[inline]
2954    pub const fn all() -> Self {
2955        Self(63u32)
2956    }
2957    pub const NONE: Self = Self(0u32);
2958    ///Bit 0.
2959    pub const INDIRECTED_DST_IMPLICIT_DATA: Self = Self(1u32);
2960    ///Bit 1.
2961    pub const INDIRECTED_SCRATCH_DATA: Self = Self(2u32);
2962    ///Bit 2.
2963    pub const INDIRECTED_DST_ADDRESS_ARRAY: Self = Self(4u32);
2964    ///Bit 3.
2965    pub const INDIRECTED_DST_SIZES_ARRAY: Self = Self(8u32);
2966    ///Bit 4.
2967    pub const INDIRECTED_SRC_INFOS_ARRAY: Self = Self(16u32);
2968    ///Bit 5.
2969    pub const INDIRECTED_SRC_INFOS_COUNT: Self = Self(32u32);
2970}
2971impl core::ops::BitOr for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2972    type Output = Self;
2973    #[inline]
2974    fn bitor(self, rhs: Self) -> Self {
2975        Self(self.0 | rhs.0)
2976    }
2977}
2978impl core::ops::BitOrAssign for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2979    #[inline]
2980    fn bitor_assign(&mut self, rhs: Self) {
2981        self.0 |= rhs.0;
2982    }
2983}
2984impl core::ops::BitAnd for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2985    type Output = Self;
2986    #[inline]
2987    fn bitand(self, rhs: Self) -> Self {
2988        Self(self.0 & rhs.0)
2989    }
2990}
2991impl core::ops::BitAndAssign
2992for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2993    #[inline]
2994    fn bitand_assign(&mut self, rhs: Self) {
2995        self.0 &= rhs.0;
2996    }
2997}
2998impl core::ops::BitXor for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2999    type Output = Self;
3000    #[inline]
3001    fn bitxor(self, rhs: Self) -> Self {
3002        Self(self.0 ^ rhs.0)
3003    }
3004}
3005impl core::ops::BitXorAssign
3006for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
3007    #[inline]
3008    fn bitxor_assign(&mut self, rhs: Self) {
3009        self.0 ^= rhs.0;
3010    }
3011}
3012impl core::ops::Not for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
3013    type Output = Self;
3014    #[inline]
3015    fn not(self) -> Self {
3016        Self(!self.0)
3017    }
3018}
3019impl core::fmt::Debug for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
3020    #[allow(unused_mut, unused_variables)]
3021    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3022        let mut first = true;
3023        let mut remaining = self.0;
3024        if remaining & Self::INDIRECTED_DST_IMPLICIT_DATA.0 != 0 {
3025            if !first {
3026                f.write_str(" | ")?;
3027            }
3028            f.write_str("INDIRECTED_DST_IMPLICIT_DATA")?;
3029            remaining &= !Self::INDIRECTED_DST_IMPLICIT_DATA.0;
3030            first = false;
3031        }
3032        if remaining & Self::INDIRECTED_SCRATCH_DATA.0 != 0 {
3033            if !first {
3034                f.write_str(" | ")?;
3035            }
3036            f.write_str("INDIRECTED_SCRATCH_DATA")?;
3037            remaining &= !Self::INDIRECTED_SCRATCH_DATA.0;
3038            first = false;
3039        }
3040        if remaining & Self::INDIRECTED_DST_ADDRESS_ARRAY.0 != 0 {
3041            if !first {
3042                f.write_str(" | ")?;
3043            }
3044            f.write_str("INDIRECTED_DST_ADDRESS_ARRAY")?;
3045            remaining &= !Self::INDIRECTED_DST_ADDRESS_ARRAY.0;
3046            first = false;
3047        }
3048        if remaining & Self::INDIRECTED_DST_SIZES_ARRAY.0 != 0 {
3049            if !first {
3050                f.write_str(" | ")?;
3051            }
3052            f.write_str("INDIRECTED_DST_SIZES_ARRAY")?;
3053            remaining &= !Self::INDIRECTED_DST_SIZES_ARRAY.0;
3054            first = false;
3055        }
3056        if remaining & Self::INDIRECTED_SRC_INFOS_ARRAY.0 != 0 {
3057            if !first {
3058                f.write_str(" | ")?;
3059            }
3060            f.write_str("INDIRECTED_SRC_INFOS_ARRAY")?;
3061            remaining &= !Self::INDIRECTED_SRC_INFOS_ARRAY.0;
3062            first = false;
3063        }
3064        if remaining & Self::INDIRECTED_SRC_INFOS_COUNT.0 != 0 {
3065            if !first {
3066                f.write_str(" | ")?;
3067            }
3068            f.write_str("INDIRECTED_SRC_INFOS_COUNT")?;
3069            remaining &= !Self::INDIRECTED_SRC_INFOS_COUNT.0;
3070            first = false;
3071        }
3072        if remaining != 0u32 {
3073            if !first {
3074                f.write_str(" | ")?;
3075            }
3076            write!(f, "{:#x}", remaining)?;
3077        } else if first {
3078            f.write_str("(empty)")?;
3079        }
3080        Ok(())
3081    }
3082}
3083///[`VkClusterAccelerationStructureClusterFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClusterFlagBitsNV.html)
3084#[repr(transparent)]
3085#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3086#[doc(alias = "VkClusterAccelerationStructureClusterFlagBitsNV")]
3087pub struct ClusterAccelerationStructureClusterFlagBitsNV(u32);
3088impl ClusterAccelerationStructureClusterFlagBitsNV {
3089    #[inline]
3090    pub const fn empty() -> Self {
3091        Self(0u32)
3092    }
3093    #[inline]
3094    pub const fn from_raw(value: u32) -> Self {
3095        Self(value)
3096    }
3097    #[inline]
3098    pub const fn as_raw(self) -> u32 {
3099        self.0
3100    }
3101    #[inline]
3102    pub const fn is_empty(self) -> bool {
3103        self.0 == 0u32
3104    }
3105    #[inline]
3106    pub const fn contains(self, other: Self) -> bool {
3107        (self.0 & other.0) == other.0
3108    }
3109    #[inline]
3110    pub const fn all() -> Self {
3111        Self(1u32)
3112    }
3113    ///Bit 0.
3114    pub const ALLOW_DISABLE_OPACITY_MICROMAPS: Self = Self(1u32);
3115}
3116impl core::ops::BitOr for ClusterAccelerationStructureClusterFlagBitsNV {
3117    type Output = Self;
3118    #[inline]
3119    fn bitor(self, rhs: Self) -> Self {
3120        Self(self.0 | rhs.0)
3121    }
3122}
3123impl core::ops::BitOrAssign for ClusterAccelerationStructureClusterFlagBitsNV {
3124    #[inline]
3125    fn bitor_assign(&mut self, rhs: Self) {
3126        self.0 |= rhs.0;
3127    }
3128}
3129impl core::ops::BitAnd for ClusterAccelerationStructureClusterFlagBitsNV {
3130    type Output = Self;
3131    #[inline]
3132    fn bitand(self, rhs: Self) -> Self {
3133        Self(self.0 & rhs.0)
3134    }
3135}
3136impl core::ops::BitAndAssign for ClusterAccelerationStructureClusterFlagBitsNV {
3137    #[inline]
3138    fn bitand_assign(&mut self, rhs: Self) {
3139        self.0 &= rhs.0;
3140    }
3141}
3142impl core::ops::BitXor for ClusterAccelerationStructureClusterFlagBitsNV {
3143    type Output = Self;
3144    #[inline]
3145    fn bitxor(self, rhs: Self) -> Self {
3146        Self(self.0 ^ rhs.0)
3147    }
3148}
3149impl core::ops::BitXorAssign for ClusterAccelerationStructureClusterFlagBitsNV {
3150    #[inline]
3151    fn bitxor_assign(&mut self, rhs: Self) {
3152        self.0 ^= rhs.0;
3153    }
3154}
3155impl core::ops::Not for ClusterAccelerationStructureClusterFlagBitsNV {
3156    type Output = Self;
3157    #[inline]
3158    fn not(self) -> Self {
3159        Self(!self.0)
3160    }
3161}
3162impl core::fmt::Debug for ClusterAccelerationStructureClusterFlagBitsNV {
3163    #[allow(unused_mut, unused_variables)]
3164    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3165        let mut first = true;
3166        let mut remaining = self.0;
3167        if remaining & Self::ALLOW_DISABLE_OPACITY_MICROMAPS.0 != 0 {
3168            if !first {
3169                f.write_str(" | ")?;
3170            }
3171            f.write_str("ALLOW_DISABLE_OPACITY_MICROMAPS")?;
3172            remaining &= !Self::ALLOW_DISABLE_OPACITY_MICROMAPS.0;
3173            first = false;
3174        }
3175        if remaining != 0u32 {
3176            if !first {
3177                f.write_str(" | ")?;
3178            }
3179            write!(f, "{:#x}", remaining)?;
3180        } else if first {
3181            f.write_str("(empty)")?;
3182        }
3183        Ok(())
3184    }
3185}
3186///[`VkClusterAccelerationStructureGeometryFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryFlagBitsNV.html)
3187#[repr(transparent)]
3188#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3189#[doc(alias = "VkClusterAccelerationStructureGeometryFlagBitsNV")]
3190pub struct ClusterAccelerationStructureGeometryFlagBitsNV(u32);
3191impl ClusterAccelerationStructureGeometryFlagBitsNV {
3192    #[inline]
3193    pub const fn empty() -> Self {
3194        Self(0u32)
3195    }
3196    #[inline]
3197    pub const fn from_raw(value: u32) -> Self {
3198        Self(value)
3199    }
3200    #[inline]
3201    pub const fn as_raw(self) -> u32 {
3202        self.0
3203    }
3204    #[inline]
3205    pub const fn is_empty(self) -> bool {
3206        self.0 == 0u32
3207    }
3208    #[inline]
3209    pub const fn contains(self, other: Self) -> bool {
3210        (self.0 & other.0) == other.0
3211    }
3212    #[inline]
3213    pub const fn all() -> Self {
3214        Self(7u32)
3215    }
3216    ///Bit 0.
3217    pub const CULL_DISABLE: Self = Self(1u32);
3218    ///Bit 1.
3219    pub const NO_DUPLICATE_ANYHIT_INVOCATION: Self = Self(2u32);
3220    ///Bit 2.
3221    pub const OPAQUE: Self = Self(4u32);
3222}
3223impl core::ops::BitOr for ClusterAccelerationStructureGeometryFlagBitsNV {
3224    type Output = Self;
3225    #[inline]
3226    fn bitor(self, rhs: Self) -> Self {
3227        Self(self.0 | rhs.0)
3228    }
3229}
3230impl core::ops::BitOrAssign for ClusterAccelerationStructureGeometryFlagBitsNV {
3231    #[inline]
3232    fn bitor_assign(&mut self, rhs: Self) {
3233        self.0 |= rhs.0;
3234    }
3235}
3236impl core::ops::BitAnd for ClusterAccelerationStructureGeometryFlagBitsNV {
3237    type Output = Self;
3238    #[inline]
3239    fn bitand(self, rhs: Self) -> Self {
3240        Self(self.0 & rhs.0)
3241    }
3242}
3243impl core::ops::BitAndAssign for ClusterAccelerationStructureGeometryFlagBitsNV {
3244    #[inline]
3245    fn bitand_assign(&mut self, rhs: Self) {
3246        self.0 &= rhs.0;
3247    }
3248}
3249impl core::ops::BitXor for ClusterAccelerationStructureGeometryFlagBitsNV {
3250    type Output = Self;
3251    #[inline]
3252    fn bitxor(self, rhs: Self) -> Self {
3253        Self(self.0 ^ rhs.0)
3254    }
3255}
3256impl core::ops::BitXorAssign for ClusterAccelerationStructureGeometryFlagBitsNV {
3257    #[inline]
3258    fn bitxor_assign(&mut self, rhs: Self) {
3259        self.0 ^= rhs.0;
3260    }
3261}
3262impl core::ops::Not for ClusterAccelerationStructureGeometryFlagBitsNV {
3263    type Output = Self;
3264    #[inline]
3265    fn not(self) -> Self {
3266        Self(!self.0)
3267    }
3268}
3269impl core::fmt::Debug for ClusterAccelerationStructureGeometryFlagBitsNV {
3270    #[allow(unused_mut, unused_variables)]
3271    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3272        let mut first = true;
3273        let mut remaining = self.0;
3274        if remaining & Self::CULL_DISABLE.0 != 0 {
3275            if !first {
3276                f.write_str(" | ")?;
3277            }
3278            f.write_str("CULL_DISABLE")?;
3279            remaining &= !Self::CULL_DISABLE.0;
3280            first = false;
3281        }
3282        if remaining & Self::NO_DUPLICATE_ANYHIT_INVOCATION.0 != 0 {
3283            if !first {
3284                f.write_str(" | ")?;
3285            }
3286            f.write_str("NO_DUPLICATE_ANYHIT_INVOCATION")?;
3287            remaining &= !Self::NO_DUPLICATE_ANYHIT_INVOCATION.0;
3288            first = false;
3289        }
3290        if remaining & Self::OPAQUE.0 != 0 {
3291            if !first {
3292                f.write_str(" | ")?;
3293            }
3294            f.write_str("OPAQUE")?;
3295            remaining &= !Self::OPAQUE.0;
3296            first = false;
3297        }
3298        if remaining != 0u32 {
3299            if !first {
3300                f.write_str(" | ")?;
3301            }
3302            write!(f, "{:#x}", remaining)?;
3303        } else if first {
3304            f.write_str("(empty)")?;
3305        }
3306        Ok(())
3307    }
3308}
3309///[`VkClusterAccelerationStructureIndexFormatFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureIndexFormatFlagBitsNV.html)
3310#[repr(transparent)]
3311#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3312#[doc(alias = "VkClusterAccelerationStructureIndexFormatFlagBitsNV")]
3313pub struct ClusterAccelerationStructureIndexFormatFlagBitsNV(u32);
3314impl ClusterAccelerationStructureIndexFormatFlagBitsNV {
3315    #[inline]
3316    pub const fn empty() -> Self {
3317        Self(0u32)
3318    }
3319    #[inline]
3320    pub const fn from_raw(value: u32) -> Self {
3321        Self(value)
3322    }
3323    #[inline]
3324    pub const fn as_raw(self) -> u32 {
3325        self.0
3326    }
3327    #[inline]
3328    pub const fn is_empty(self) -> bool {
3329        self.0 == 0u32
3330    }
3331    #[inline]
3332    pub const fn contains(self, other: Self) -> bool {
3333        (self.0 & other.0) == other.0
3334    }
3335    #[inline]
3336    pub const fn all() -> Self {
3337        Self(7u32)
3338    }
3339    ///Bit 0.
3340    pub const _8BIT: Self = Self(1u32);
3341    ///Bit 1.
3342    pub const _16BIT: Self = Self(2u32);
3343    ///Bit 2.
3344    pub const _32BIT: Self = Self(4u32);
3345}
3346impl core::ops::BitOr for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3347    type Output = Self;
3348    #[inline]
3349    fn bitor(self, rhs: Self) -> Self {
3350        Self(self.0 | rhs.0)
3351    }
3352}
3353impl core::ops::BitOrAssign for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3354    #[inline]
3355    fn bitor_assign(&mut self, rhs: Self) {
3356        self.0 |= rhs.0;
3357    }
3358}
3359impl core::ops::BitAnd for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3360    type Output = Self;
3361    #[inline]
3362    fn bitand(self, rhs: Self) -> Self {
3363        Self(self.0 & rhs.0)
3364    }
3365}
3366impl core::ops::BitAndAssign for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3367    #[inline]
3368    fn bitand_assign(&mut self, rhs: Self) {
3369        self.0 &= rhs.0;
3370    }
3371}
3372impl core::ops::BitXor for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3373    type Output = Self;
3374    #[inline]
3375    fn bitxor(self, rhs: Self) -> Self {
3376        Self(self.0 ^ rhs.0)
3377    }
3378}
3379impl core::ops::BitXorAssign for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3380    #[inline]
3381    fn bitxor_assign(&mut self, rhs: Self) {
3382        self.0 ^= rhs.0;
3383    }
3384}
3385impl core::ops::Not for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3386    type Output = Self;
3387    #[inline]
3388    fn not(self) -> Self {
3389        Self(!self.0)
3390    }
3391}
3392impl core::fmt::Debug for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3393    #[allow(unused_mut, unused_variables)]
3394    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3395        let mut first = true;
3396        let mut remaining = self.0;
3397        if remaining & Self::_8BIT.0 != 0 {
3398            if !first {
3399                f.write_str(" | ")?;
3400            }
3401            f.write_str("_8BIT")?;
3402            remaining &= !Self::_8BIT.0;
3403            first = false;
3404        }
3405        if remaining & Self::_16BIT.0 != 0 {
3406            if !first {
3407                f.write_str(" | ")?;
3408            }
3409            f.write_str("_16BIT")?;
3410            remaining &= !Self::_16BIT.0;
3411            first = false;
3412        }
3413        if remaining & Self::_32BIT.0 != 0 {
3414            if !first {
3415                f.write_str(" | ")?;
3416            }
3417            f.write_str("_32BIT")?;
3418            remaining &= !Self::_32BIT.0;
3419            first = false;
3420        }
3421        if remaining != 0u32 {
3422            if !first {
3423                f.write_str(" | ")?;
3424            }
3425            write!(f, "{:#x}", remaining)?;
3426        } else if first {
3427            f.write_str("(empty)")?;
3428        }
3429        Ok(())
3430    }
3431}
3432///[`VkColorComponentFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorComponentFlagBits.html)
3433#[repr(transparent)]
3434#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3435#[doc(alias = "VkColorComponentFlagBits")]
3436pub struct ColorComponentFlagBits(u32);
3437impl ColorComponentFlagBits {
3438    #[inline]
3439    pub const fn empty() -> Self {
3440        Self(0u32)
3441    }
3442    #[inline]
3443    pub const fn from_raw(value: u32) -> Self {
3444        Self(value)
3445    }
3446    #[inline]
3447    pub const fn as_raw(self) -> u32 {
3448        self.0
3449    }
3450    #[inline]
3451    pub const fn is_empty(self) -> bool {
3452        self.0 == 0u32
3453    }
3454    #[inline]
3455    pub const fn contains(self, other: Self) -> bool {
3456        (self.0 & other.0) == other.0
3457    }
3458    #[inline]
3459    pub const fn all() -> Self {
3460        Self(15u32)
3461    }
3462    ///Bit 0.
3463    pub const R: Self = Self(1u32);
3464    ///Bit 1.
3465    pub const G: Self = Self(2u32);
3466    ///Bit 2.
3467    pub const B: Self = Self(4u32);
3468    ///Bit 3.
3469    pub const A: Self = Self(8u32);
3470}
3471impl core::ops::BitOr for ColorComponentFlagBits {
3472    type Output = Self;
3473    #[inline]
3474    fn bitor(self, rhs: Self) -> Self {
3475        Self(self.0 | rhs.0)
3476    }
3477}
3478impl core::ops::BitOrAssign for ColorComponentFlagBits {
3479    #[inline]
3480    fn bitor_assign(&mut self, rhs: Self) {
3481        self.0 |= rhs.0;
3482    }
3483}
3484impl core::ops::BitAnd for ColorComponentFlagBits {
3485    type Output = Self;
3486    #[inline]
3487    fn bitand(self, rhs: Self) -> Self {
3488        Self(self.0 & rhs.0)
3489    }
3490}
3491impl core::ops::BitAndAssign for ColorComponentFlagBits {
3492    #[inline]
3493    fn bitand_assign(&mut self, rhs: Self) {
3494        self.0 &= rhs.0;
3495    }
3496}
3497impl core::ops::BitXor for ColorComponentFlagBits {
3498    type Output = Self;
3499    #[inline]
3500    fn bitxor(self, rhs: Self) -> Self {
3501        Self(self.0 ^ rhs.0)
3502    }
3503}
3504impl core::ops::BitXorAssign for ColorComponentFlagBits {
3505    #[inline]
3506    fn bitxor_assign(&mut self, rhs: Self) {
3507        self.0 ^= rhs.0;
3508    }
3509}
3510impl core::ops::Not for ColorComponentFlagBits {
3511    type Output = Self;
3512    #[inline]
3513    fn not(self) -> Self {
3514        Self(!self.0)
3515    }
3516}
3517impl core::fmt::Debug for ColorComponentFlagBits {
3518    #[allow(unused_mut, unused_variables)]
3519    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3520        let mut first = true;
3521        let mut remaining = self.0;
3522        if remaining & Self::R.0 != 0 {
3523            if !first {
3524                f.write_str(" | ")?;
3525            }
3526            f.write_str("R")?;
3527            remaining &= !Self::R.0;
3528            first = false;
3529        }
3530        if remaining & Self::G.0 != 0 {
3531            if !first {
3532                f.write_str(" | ")?;
3533            }
3534            f.write_str("G")?;
3535            remaining &= !Self::G.0;
3536            first = false;
3537        }
3538        if remaining & Self::B.0 != 0 {
3539            if !first {
3540                f.write_str(" | ")?;
3541            }
3542            f.write_str("B")?;
3543            remaining &= !Self::B.0;
3544            first = false;
3545        }
3546        if remaining & Self::A.0 != 0 {
3547            if !first {
3548                f.write_str(" | ")?;
3549            }
3550            f.write_str("A")?;
3551            remaining &= !Self::A.0;
3552            first = false;
3553        }
3554        if remaining != 0u32 {
3555            if !first {
3556                f.write_str(" | ")?;
3557            }
3558            write!(f, "{:#x}", remaining)?;
3559        } else if first {
3560            f.write_str("(empty)")?;
3561        }
3562        Ok(())
3563    }
3564}
3565///[`VkCommandBufferResetFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferResetFlagBits.html)
3566#[repr(transparent)]
3567#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3568#[doc(alias = "VkCommandBufferResetFlagBits")]
3569pub struct CommandBufferResetFlagBits(u32);
3570impl CommandBufferResetFlagBits {
3571    #[inline]
3572    pub const fn empty() -> Self {
3573        Self(0u32)
3574    }
3575    #[inline]
3576    pub const fn from_raw(value: u32) -> Self {
3577        Self(value)
3578    }
3579    #[inline]
3580    pub const fn as_raw(self) -> u32 {
3581        self.0
3582    }
3583    #[inline]
3584    pub const fn is_empty(self) -> bool {
3585        self.0 == 0u32
3586    }
3587    #[inline]
3588    pub const fn contains(self, other: Self) -> bool {
3589        (self.0 & other.0) == other.0
3590    }
3591    #[inline]
3592    pub const fn all() -> Self {
3593        Self(1u32)
3594    }
3595    ///Bit 0.
3596    pub const RELEASE_RESOURCES: Self = Self(1u32);
3597}
3598impl core::ops::BitOr for CommandBufferResetFlagBits {
3599    type Output = Self;
3600    #[inline]
3601    fn bitor(self, rhs: Self) -> Self {
3602        Self(self.0 | rhs.0)
3603    }
3604}
3605impl core::ops::BitOrAssign for CommandBufferResetFlagBits {
3606    #[inline]
3607    fn bitor_assign(&mut self, rhs: Self) {
3608        self.0 |= rhs.0;
3609    }
3610}
3611impl core::ops::BitAnd for CommandBufferResetFlagBits {
3612    type Output = Self;
3613    #[inline]
3614    fn bitand(self, rhs: Self) -> Self {
3615        Self(self.0 & rhs.0)
3616    }
3617}
3618impl core::ops::BitAndAssign for CommandBufferResetFlagBits {
3619    #[inline]
3620    fn bitand_assign(&mut self, rhs: Self) {
3621        self.0 &= rhs.0;
3622    }
3623}
3624impl core::ops::BitXor for CommandBufferResetFlagBits {
3625    type Output = Self;
3626    #[inline]
3627    fn bitxor(self, rhs: Self) -> Self {
3628        Self(self.0 ^ rhs.0)
3629    }
3630}
3631impl core::ops::BitXorAssign for CommandBufferResetFlagBits {
3632    #[inline]
3633    fn bitxor_assign(&mut self, rhs: Self) {
3634        self.0 ^= rhs.0;
3635    }
3636}
3637impl core::ops::Not for CommandBufferResetFlagBits {
3638    type Output = Self;
3639    #[inline]
3640    fn not(self) -> Self {
3641        Self(!self.0)
3642    }
3643}
3644impl core::fmt::Debug for CommandBufferResetFlagBits {
3645    #[allow(unused_mut, unused_variables)]
3646    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3647        let mut first = true;
3648        let mut remaining = self.0;
3649        if remaining & Self::RELEASE_RESOURCES.0 != 0 {
3650            if !first {
3651                f.write_str(" | ")?;
3652            }
3653            f.write_str("RELEASE_RESOURCES")?;
3654            remaining &= !Self::RELEASE_RESOURCES.0;
3655            first = false;
3656        }
3657        if remaining != 0u32 {
3658            if !first {
3659                f.write_str(" | ")?;
3660            }
3661            write!(f, "{:#x}", remaining)?;
3662        } else if first {
3663            f.write_str("(empty)")?;
3664        }
3665        Ok(())
3666    }
3667}
3668///[`VkCommandBufferUsageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferUsageFlagBits.html)
3669#[repr(transparent)]
3670#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3671#[doc(alias = "VkCommandBufferUsageFlagBits")]
3672pub struct CommandBufferUsageFlagBits(u32);
3673impl CommandBufferUsageFlagBits {
3674    #[inline]
3675    pub const fn empty() -> Self {
3676        Self(0u32)
3677    }
3678    #[inline]
3679    pub const fn from_raw(value: u32) -> Self {
3680        Self(value)
3681    }
3682    #[inline]
3683    pub const fn as_raw(self) -> u32 {
3684        self.0
3685    }
3686    #[inline]
3687    pub const fn is_empty(self) -> bool {
3688        self.0 == 0u32
3689    }
3690    #[inline]
3691    pub const fn contains(self, other: Self) -> bool {
3692        (self.0 & other.0) == other.0
3693    }
3694    #[inline]
3695    pub const fn all() -> Self {
3696        Self(7u32)
3697    }
3698    ///Bit 0.
3699    pub const ONE_TIME_SUBMIT: Self = Self(1u32);
3700    ///Bit 1.
3701    pub const RENDER_PASS_CONTINUE: Self = Self(2u32);
3702    ///Bit 2.
3703    pub const SIMULTANEOUS_USE: Self = Self(4u32);
3704}
3705impl core::ops::BitOr for CommandBufferUsageFlagBits {
3706    type Output = Self;
3707    #[inline]
3708    fn bitor(self, rhs: Self) -> Self {
3709        Self(self.0 | rhs.0)
3710    }
3711}
3712impl core::ops::BitOrAssign for CommandBufferUsageFlagBits {
3713    #[inline]
3714    fn bitor_assign(&mut self, rhs: Self) {
3715        self.0 |= rhs.0;
3716    }
3717}
3718impl core::ops::BitAnd for CommandBufferUsageFlagBits {
3719    type Output = Self;
3720    #[inline]
3721    fn bitand(self, rhs: Self) -> Self {
3722        Self(self.0 & rhs.0)
3723    }
3724}
3725impl core::ops::BitAndAssign for CommandBufferUsageFlagBits {
3726    #[inline]
3727    fn bitand_assign(&mut self, rhs: Self) {
3728        self.0 &= rhs.0;
3729    }
3730}
3731impl core::ops::BitXor for CommandBufferUsageFlagBits {
3732    type Output = Self;
3733    #[inline]
3734    fn bitxor(self, rhs: Self) -> Self {
3735        Self(self.0 ^ rhs.0)
3736    }
3737}
3738impl core::ops::BitXorAssign for CommandBufferUsageFlagBits {
3739    #[inline]
3740    fn bitxor_assign(&mut self, rhs: Self) {
3741        self.0 ^= rhs.0;
3742    }
3743}
3744impl core::ops::Not for CommandBufferUsageFlagBits {
3745    type Output = Self;
3746    #[inline]
3747    fn not(self) -> Self {
3748        Self(!self.0)
3749    }
3750}
3751impl core::fmt::Debug for CommandBufferUsageFlagBits {
3752    #[allow(unused_mut, unused_variables)]
3753    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3754        let mut first = true;
3755        let mut remaining = self.0;
3756        if remaining & Self::ONE_TIME_SUBMIT.0 != 0 {
3757            if !first {
3758                f.write_str(" | ")?;
3759            }
3760            f.write_str("ONE_TIME_SUBMIT")?;
3761            remaining &= !Self::ONE_TIME_SUBMIT.0;
3762            first = false;
3763        }
3764        if remaining & Self::RENDER_PASS_CONTINUE.0 != 0 {
3765            if !first {
3766                f.write_str(" | ")?;
3767            }
3768            f.write_str("RENDER_PASS_CONTINUE")?;
3769            remaining &= !Self::RENDER_PASS_CONTINUE.0;
3770            first = false;
3771        }
3772        if remaining & Self::SIMULTANEOUS_USE.0 != 0 {
3773            if !first {
3774                f.write_str(" | ")?;
3775            }
3776            f.write_str("SIMULTANEOUS_USE")?;
3777            remaining &= !Self::SIMULTANEOUS_USE.0;
3778            first = false;
3779        }
3780        if remaining != 0u32 {
3781            if !first {
3782                f.write_str(" | ")?;
3783            }
3784            write!(f, "{:#x}", remaining)?;
3785        } else if first {
3786            f.write_str("(empty)")?;
3787        }
3788        Ok(())
3789    }
3790}
3791///[`VkCommandPoolCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateFlagBits.html)
3792#[repr(transparent)]
3793#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3794#[doc(alias = "VkCommandPoolCreateFlagBits")]
3795pub struct CommandPoolCreateFlagBits(u32);
3796impl CommandPoolCreateFlagBits {
3797    #[inline]
3798    pub const fn empty() -> Self {
3799        Self(0u32)
3800    }
3801    #[inline]
3802    pub const fn from_raw(value: u32) -> Self {
3803        Self(value)
3804    }
3805    #[inline]
3806    pub const fn as_raw(self) -> u32 {
3807        self.0
3808    }
3809    #[inline]
3810    pub const fn is_empty(self) -> bool {
3811        self.0 == 0u32
3812    }
3813    #[inline]
3814    pub const fn contains(self, other: Self) -> bool {
3815        (self.0 & other.0) == other.0
3816    }
3817    #[inline]
3818    pub const fn all() -> Self {
3819        Self(7u32)
3820    }
3821    ///Bit 0.
3822    pub const TRANSIENT: Self = Self(1u32);
3823    ///Bit 1.
3824    pub const RESET_COMMAND_BUFFER: Self = Self(2u32);
3825    ///Bit 2.
3826    pub const PROTECTED: Self = Self(4u32);
3827}
3828impl core::ops::BitOr for CommandPoolCreateFlagBits {
3829    type Output = Self;
3830    #[inline]
3831    fn bitor(self, rhs: Self) -> Self {
3832        Self(self.0 | rhs.0)
3833    }
3834}
3835impl core::ops::BitOrAssign for CommandPoolCreateFlagBits {
3836    #[inline]
3837    fn bitor_assign(&mut self, rhs: Self) {
3838        self.0 |= rhs.0;
3839    }
3840}
3841impl core::ops::BitAnd for CommandPoolCreateFlagBits {
3842    type Output = Self;
3843    #[inline]
3844    fn bitand(self, rhs: Self) -> Self {
3845        Self(self.0 & rhs.0)
3846    }
3847}
3848impl core::ops::BitAndAssign for CommandPoolCreateFlagBits {
3849    #[inline]
3850    fn bitand_assign(&mut self, rhs: Self) {
3851        self.0 &= rhs.0;
3852    }
3853}
3854impl core::ops::BitXor for CommandPoolCreateFlagBits {
3855    type Output = Self;
3856    #[inline]
3857    fn bitxor(self, rhs: Self) -> Self {
3858        Self(self.0 ^ rhs.0)
3859    }
3860}
3861impl core::ops::BitXorAssign for CommandPoolCreateFlagBits {
3862    #[inline]
3863    fn bitxor_assign(&mut self, rhs: Self) {
3864        self.0 ^= rhs.0;
3865    }
3866}
3867impl core::ops::Not for CommandPoolCreateFlagBits {
3868    type Output = Self;
3869    #[inline]
3870    fn not(self) -> Self {
3871        Self(!self.0)
3872    }
3873}
3874impl core::fmt::Debug for CommandPoolCreateFlagBits {
3875    #[allow(unused_mut, unused_variables)]
3876    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3877        let mut first = true;
3878        let mut remaining = self.0;
3879        if remaining & Self::TRANSIENT.0 != 0 {
3880            if !first {
3881                f.write_str(" | ")?;
3882            }
3883            f.write_str("TRANSIENT")?;
3884            remaining &= !Self::TRANSIENT.0;
3885            first = false;
3886        }
3887        if remaining & Self::RESET_COMMAND_BUFFER.0 != 0 {
3888            if !first {
3889                f.write_str(" | ")?;
3890            }
3891            f.write_str("RESET_COMMAND_BUFFER")?;
3892            remaining &= !Self::RESET_COMMAND_BUFFER.0;
3893            first = false;
3894        }
3895        if remaining & Self::PROTECTED.0 != 0 {
3896            if !first {
3897                f.write_str(" | ")?;
3898            }
3899            f.write_str("PROTECTED")?;
3900            remaining &= !Self::PROTECTED.0;
3901            first = false;
3902        }
3903        if remaining != 0u32 {
3904            if !first {
3905                f.write_str(" | ")?;
3906            }
3907            write!(f, "{:#x}", remaining)?;
3908        } else if first {
3909            f.write_str("(empty)")?;
3910        }
3911        Ok(())
3912    }
3913}
3914///[`VkCommandPoolResetFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolResetFlagBits.html)
3915#[repr(transparent)]
3916#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3917#[doc(alias = "VkCommandPoolResetFlagBits")]
3918pub struct CommandPoolResetFlagBits(u32);
3919impl CommandPoolResetFlagBits {
3920    #[inline]
3921    pub const fn empty() -> Self {
3922        Self(0u32)
3923    }
3924    #[inline]
3925    pub const fn from_raw(value: u32) -> Self {
3926        Self(value)
3927    }
3928    #[inline]
3929    pub const fn as_raw(self) -> u32 {
3930        self.0
3931    }
3932    #[inline]
3933    pub const fn is_empty(self) -> bool {
3934        self.0 == 0u32
3935    }
3936    #[inline]
3937    pub const fn contains(self, other: Self) -> bool {
3938        (self.0 & other.0) == other.0
3939    }
3940    #[inline]
3941    pub const fn all() -> Self {
3942        Self(1u32)
3943    }
3944    ///Bit 0.
3945    pub const RELEASE_RESOURCES: Self = Self(1u32);
3946}
3947impl core::ops::BitOr for CommandPoolResetFlagBits {
3948    type Output = Self;
3949    #[inline]
3950    fn bitor(self, rhs: Self) -> Self {
3951        Self(self.0 | rhs.0)
3952    }
3953}
3954impl core::ops::BitOrAssign for CommandPoolResetFlagBits {
3955    #[inline]
3956    fn bitor_assign(&mut self, rhs: Self) {
3957        self.0 |= rhs.0;
3958    }
3959}
3960impl core::ops::BitAnd for CommandPoolResetFlagBits {
3961    type Output = Self;
3962    #[inline]
3963    fn bitand(self, rhs: Self) -> Self {
3964        Self(self.0 & rhs.0)
3965    }
3966}
3967impl core::ops::BitAndAssign for CommandPoolResetFlagBits {
3968    #[inline]
3969    fn bitand_assign(&mut self, rhs: Self) {
3970        self.0 &= rhs.0;
3971    }
3972}
3973impl core::ops::BitXor for CommandPoolResetFlagBits {
3974    type Output = Self;
3975    #[inline]
3976    fn bitxor(self, rhs: Self) -> Self {
3977        Self(self.0 ^ rhs.0)
3978    }
3979}
3980impl core::ops::BitXorAssign for CommandPoolResetFlagBits {
3981    #[inline]
3982    fn bitxor_assign(&mut self, rhs: Self) {
3983        self.0 ^= rhs.0;
3984    }
3985}
3986impl core::ops::Not for CommandPoolResetFlagBits {
3987    type Output = Self;
3988    #[inline]
3989    fn not(self) -> Self {
3990        Self(!self.0)
3991    }
3992}
3993impl core::fmt::Debug for CommandPoolResetFlagBits {
3994    #[allow(unused_mut, unused_variables)]
3995    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3996        let mut first = true;
3997        let mut remaining = self.0;
3998        if remaining & Self::RELEASE_RESOURCES.0 != 0 {
3999            if !first {
4000                f.write_str(" | ")?;
4001            }
4002            f.write_str("RELEASE_RESOURCES")?;
4003            remaining &= !Self::RELEASE_RESOURCES.0;
4004            first = false;
4005        }
4006        if remaining != 0u32 {
4007            if !first {
4008                f.write_str(" | ")?;
4009            }
4010            write!(f, "{:#x}", remaining)?;
4011        } else if first {
4012            f.write_str("(empty)")?;
4013        }
4014        Ok(())
4015    }
4016}
4017///[`VkCompositeAlphaFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompositeAlphaFlagBitsKHR.html)
4018#[repr(transparent)]
4019#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4020#[doc(alias = "VkCompositeAlphaFlagBitsKHR")]
4021pub struct CompositeAlphaFlagBitsKHR(u32);
4022impl CompositeAlphaFlagBitsKHR {
4023    #[inline]
4024    pub const fn empty() -> Self {
4025        Self(0u32)
4026    }
4027    #[inline]
4028    pub const fn from_raw(value: u32) -> Self {
4029        Self(value)
4030    }
4031    #[inline]
4032    pub const fn as_raw(self) -> u32 {
4033        self.0
4034    }
4035    #[inline]
4036    pub const fn is_empty(self) -> bool {
4037        self.0 == 0u32
4038    }
4039    #[inline]
4040    pub const fn contains(self, other: Self) -> bool {
4041        (self.0 & other.0) == other.0
4042    }
4043    #[inline]
4044    pub const fn all() -> Self {
4045        Self(15u32)
4046    }
4047    ///Bit 0.
4048    pub const OPAQUE: Self = Self(1u32);
4049    ///Bit 1.
4050    pub const PRE_MULTIPLIED: Self = Self(2u32);
4051    ///Bit 2.
4052    pub const POST_MULTIPLIED: Self = Self(4u32);
4053    ///Bit 3.
4054    pub const INHERIT: Self = Self(8u32);
4055}
4056impl core::ops::BitOr for CompositeAlphaFlagBitsKHR {
4057    type Output = Self;
4058    #[inline]
4059    fn bitor(self, rhs: Self) -> Self {
4060        Self(self.0 | rhs.0)
4061    }
4062}
4063impl core::ops::BitOrAssign for CompositeAlphaFlagBitsKHR {
4064    #[inline]
4065    fn bitor_assign(&mut self, rhs: Self) {
4066        self.0 |= rhs.0;
4067    }
4068}
4069impl core::ops::BitAnd for CompositeAlphaFlagBitsKHR {
4070    type Output = Self;
4071    #[inline]
4072    fn bitand(self, rhs: Self) -> Self {
4073        Self(self.0 & rhs.0)
4074    }
4075}
4076impl core::ops::BitAndAssign for CompositeAlphaFlagBitsKHR {
4077    #[inline]
4078    fn bitand_assign(&mut self, rhs: Self) {
4079        self.0 &= rhs.0;
4080    }
4081}
4082impl core::ops::BitXor for CompositeAlphaFlagBitsKHR {
4083    type Output = Self;
4084    #[inline]
4085    fn bitxor(self, rhs: Self) -> Self {
4086        Self(self.0 ^ rhs.0)
4087    }
4088}
4089impl core::ops::BitXorAssign for CompositeAlphaFlagBitsKHR {
4090    #[inline]
4091    fn bitxor_assign(&mut self, rhs: Self) {
4092        self.0 ^= rhs.0;
4093    }
4094}
4095impl core::ops::Not for CompositeAlphaFlagBitsKHR {
4096    type Output = Self;
4097    #[inline]
4098    fn not(self) -> Self {
4099        Self(!self.0)
4100    }
4101}
4102impl core::fmt::Debug for CompositeAlphaFlagBitsKHR {
4103    #[allow(unused_mut, unused_variables)]
4104    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4105        let mut first = true;
4106        let mut remaining = self.0;
4107        if remaining & Self::OPAQUE.0 != 0 {
4108            if !first {
4109                f.write_str(" | ")?;
4110            }
4111            f.write_str("OPAQUE")?;
4112            remaining &= !Self::OPAQUE.0;
4113            first = false;
4114        }
4115        if remaining & Self::PRE_MULTIPLIED.0 != 0 {
4116            if !first {
4117                f.write_str(" | ")?;
4118            }
4119            f.write_str("PRE_MULTIPLIED")?;
4120            remaining &= !Self::PRE_MULTIPLIED.0;
4121            first = false;
4122        }
4123        if remaining & Self::POST_MULTIPLIED.0 != 0 {
4124            if !first {
4125                f.write_str(" | ")?;
4126            }
4127            f.write_str("POST_MULTIPLIED")?;
4128            remaining &= !Self::POST_MULTIPLIED.0;
4129            first = false;
4130        }
4131        if remaining & Self::INHERIT.0 != 0 {
4132            if !first {
4133                f.write_str(" | ")?;
4134            }
4135            f.write_str("INHERIT")?;
4136            remaining &= !Self::INHERIT.0;
4137            first = false;
4138        }
4139        if remaining != 0u32 {
4140            if !first {
4141                f.write_str(" | ")?;
4142            }
4143            write!(f, "{:#x}", remaining)?;
4144        } else if first {
4145            f.write_str("(empty)")?;
4146        }
4147        Ok(())
4148    }
4149}
4150///[`VkConditionalRenderingFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingFlagBitsEXT.html)
4151#[repr(transparent)]
4152#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4153#[doc(alias = "VkConditionalRenderingFlagBitsEXT")]
4154pub struct ConditionalRenderingFlagBitsEXT(u32);
4155impl ConditionalRenderingFlagBitsEXT {
4156    #[inline]
4157    pub const fn empty() -> Self {
4158        Self(0u32)
4159    }
4160    #[inline]
4161    pub const fn from_raw(value: u32) -> Self {
4162        Self(value)
4163    }
4164    #[inline]
4165    pub const fn as_raw(self) -> u32 {
4166        self.0
4167    }
4168    #[inline]
4169    pub const fn is_empty(self) -> bool {
4170        self.0 == 0u32
4171    }
4172    #[inline]
4173    pub const fn contains(self, other: Self) -> bool {
4174        (self.0 & other.0) == other.0
4175    }
4176    #[inline]
4177    pub const fn all() -> Self {
4178        Self(1u32)
4179    }
4180    ///Bit 0.
4181    pub const INVERTED: Self = Self(1u32);
4182}
4183impl core::ops::BitOr for ConditionalRenderingFlagBitsEXT {
4184    type Output = Self;
4185    #[inline]
4186    fn bitor(self, rhs: Self) -> Self {
4187        Self(self.0 | rhs.0)
4188    }
4189}
4190impl core::ops::BitOrAssign for ConditionalRenderingFlagBitsEXT {
4191    #[inline]
4192    fn bitor_assign(&mut self, rhs: Self) {
4193        self.0 |= rhs.0;
4194    }
4195}
4196impl core::ops::BitAnd for ConditionalRenderingFlagBitsEXT {
4197    type Output = Self;
4198    #[inline]
4199    fn bitand(self, rhs: Self) -> Self {
4200        Self(self.0 & rhs.0)
4201    }
4202}
4203impl core::ops::BitAndAssign for ConditionalRenderingFlagBitsEXT {
4204    #[inline]
4205    fn bitand_assign(&mut self, rhs: Self) {
4206        self.0 &= rhs.0;
4207    }
4208}
4209impl core::ops::BitXor for ConditionalRenderingFlagBitsEXT {
4210    type Output = Self;
4211    #[inline]
4212    fn bitxor(self, rhs: Self) -> Self {
4213        Self(self.0 ^ rhs.0)
4214    }
4215}
4216impl core::ops::BitXorAssign for ConditionalRenderingFlagBitsEXT {
4217    #[inline]
4218    fn bitxor_assign(&mut self, rhs: Self) {
4219        self.0 ^= rhs.0;
4220    }
4221}
4222impl core::ops::Not for ConditionalRenderingFlagBitsEXT {
4223    type Output = Self;
4224    #[inline]
4225    fn not(self) -> Self {
4226        Self(!self.0)
4227    }
4228}
4229impl core::fmt::Debug for ConditionalRenderingFlagBitsEXT {
4230    #[allow(unused_mut, unused_variables)]
4231    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4232        let mut first = true;
4233        let mut remaining = self.0;
4234        if remaining & Self::INVERTED.0 != 0 {
4235            if !first {
4236                f.write_str(" | ")?;
4237            }
4238            f.write_str("INVERTED")?;
4239            remaining &= !Self::INVERTED.0;
4240            first = false;
4241        }
4242        if remaining != 0u32 {
4243            if !first {
4244                f.write_str(" | ")?;
4245            }
4246            write!(f, "{:#x}", remaining)?;
4247        } else if first {
4248            f.write_str("(empty)")?;
4249        }
4250        Ok(())
4251    }
4252}
4253///[`VkCullModeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCullModeFlagBits.html)
4254#[repr(transparent)]
4255#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4256#[doc(alias = "VkCullModeFlagBits")]
4257pub struct CullModeFlagBits(u32);
4258impl CullModeFlagBits {
4259    #[inline]
4260    pub const fn empty() -> Self {
4261        Self(0u32)
4262    }
4263    #[inline]
4264    pub const fn from_raw(value: u32) -> Self {
4265        Self(value)
4266    }
4267    #[inline]
4268    pub const fn as_raw(self) -> u32 {
4269        self.0
4270    }
4271    #[inline]
4272    pub const fn is_empty(self) -> bool {
4273        self.0 == 0u32
4274    }
4275    #[inline]
4276    pub const fn contains(self, other: Self) -> bool {
4277        (self.0 & other.0) == other.0
4278    }
4279    #[inline]
4280    pub const fn all() -> Self {
4281        Self(3u32)
4282    }
4283    pub const NONE: Self = Self(0u32);
4284    ///Bit 0.
4285    pub const FRONT: Self = Self(1u32);
4286    ///Bit 1.
4287    pub const BACK: Self = Self(2u32);
4288    pub const FRONT_AND_BACK: Self = Self(3u32);
4289}
4290impl core::ops::BitOr for CullModeFlagBits {
4291    type Output = Self;
4292    #[inline]
4293    fn bitor(self, rhs: Self) -> Self {
4294        Self(self.0 | rhs.0)
4295    }
4296}
4297impl core::ops::BitOrAssign for CullModeFlagBits {
4298    #[inline]
4299    fn bitor_assign(&mut self, rhs: Self) {
4300        self.0 |= rhs.0;
4301    }
4302}
4303impl core::ops::BitAnd for CullModeFlagBits {
4304    type Output = Self;
4305    #[inline]
4306    fn bitand(self, rhs: Self) -> Self {
4307        Self(self.0 & rhs.0)
4308    }
4309}
4310impl core::ops::BitAndAssign for CullModeFlagBits {
4311    #[inline]
4312    fn bitand_assign(&mut self, rhs: Self) {
4313        self.0 &= rhs.0;
4314    }
4315}
4316impl core::ops::BitXor for CullModeFlagBits {
4317    type Output = Self;
4318    #[inline]
4319    fn bitxor(self, rhs: Self) -> Self {
4320        Self(self.0 ^ rhs.0)
4321    }
4322}
4323impl core::ops::BitXorAssign for CullModeFlagBits {
4324    #[inline]
4325    fn bitxor_assign(&mut self, rhs: Self) {
4326        self.0 ^= rhs.0;
4327    }
4328}
4329impl core::ops::Not for CullModeFlagBits {
4330    type Output = Self;
4331    #[inline]
4332    fn not(self) -> Self {
4333        Self(!self.0)
4334    }
4335}
4336impl core::fmt::Debug for CullModeFlagBits {
4337    #[allow(unused_mut, unused_variables)]
4338    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4339        let mut first = true;
4340        let mut remaining = self.0;
4341        if remaining & Self::FRONT.0 != 0 {
4342            if !first {
4343                f.write_str(" | ")?;
4344            }
4345            f.write_str("FRONT")?;
4346            remaining &= !Self::FRONT.0;
4347            first = false;
4348        }
4349        if remaining & Self::BACK.0 != 0 {
4350            if !first {
4351                f.write_str(" | ")?;
4352            }
4353            f.write_str("BACK")?;
4354            remaining &= !Self::BACK.0;
4355            first = false;
4356        }
4357        if remaining != 0u32 {
4358            if !first {
4359                f.write_str(" | ")?;
4360            }
4361            write!(f, "{:#x}", remaining)?;
4362        } else if first {
4363            f.write_str("(empty)")?;
4364        }
4365        Ok(())
4366    }
4367}
4368///[`VkDataGraphPipelineDispatchFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineDispatchFlagBitsARM.html)
4369#[repr(transparent)]
4370#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4371#[doc(alias = "VkDataGraphPipelineDispatchFlagBitsARM")]
4372pub struct DataGraphPipelineDispatchFlagBitsARM(u64);
4373impl DataGraphPipelineDispatchFlagBitsARM {
4374    #[inline]
4375    pub const fn empty() -> Self {
4376        Self(0u64)
4377    }
4378    #[inline]
4379    pub const fn from_raw(value: u64) -> Self {
4380        Self(value)
4381    }
4382    #[inline]
4383    pub const fn as_raw(self) -> u64 {
4384        self.0
4385    }
4386    #[inline]
4387    pub const fn is_empty(self) -> bool {
4388        self.0 == 0u64
4389    }
4390    #[inline]
4391    pub const fn contains(self, other: Self) -> bool {
4392        (self.0 & other.0) == other.0
4393    }
4394    #[inline]
4395    pub const fn all() -> Self {
4396        Self(0u64)
4397    }
4398}
4399impl core::ops::BitOr for DataGraphPipelineDispatchFlagBitsARM {
4400    type Output = Self;
4401    #[inline]
4402    fn bitor(self, rhs: Self) -> Self {
4403        Self(self.0 | rhs.0)
4404    }
4405}
4406impl core::ops::BitOrAssign for DataGraphPipelineDispatchFlagBitsARM {
4407    #[inline]
4408    fn bitor_assign(&mut self, rhs: Self) {
4409        self.0 |= rhs.0;
4410    }
4411}
4412impl core::ops::BitAnd for DataGraphPipelineDispatchFlagBitsARM {
4413    type Output = Self;
4414    #[inline]
4415    fn bitand(self, rhs: Self) -> Self {
4416        Self(self.0 & rhs.0)
4417    }
4418}
4419impl core::ops::BitAndAssign for DataGraphPipelineDispatchFlagBitsARM {
4420    #[inline]
4421    fn bitand_assign(&mut self, rhs: Self) {
4422        self.0 &= rhs.0;
4423    }
4424}
4425impl core::ops::BitXor for DataGraphPipelineDispatchFlagBitsARM {
4426    type Output = Self;
4427    #[inline]
4428    fn bitxor(self, rhs: Self) -> Self {
4429        Self(self.0 ^ rhs.0)
4430    }
4431}
4432impl core::ops::BitXorAssign for DataGraphPipelineDispatchFlagBitsARM {
4433    #[inline]
4434    fn bitxor_assign(&mut self, rhs: Self) {
4435        self.0 ^= rhs.0;
4436    }
4437}
4438impl core::ops::Not for DataGraphPipelineDispatchFlagBitsARM {
4439    type Output = Self;
4440    #[inline]
4441    fn not(self) -> Self {
4442        Self(!self.0)
4443    }
4444}
4445impl core::fmt::Debug for DataGraphPipelineDispatchFlagBitsARM {
4446    #[allow(unused_mut, unused_variables)]
4447    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4448        let mut first = true;
4449        let mut remaining = self.0;
4450        if remaining != 0u64 {
4451            if !first {
4452                f.write_str(" | ")?;
4453            }
4454            write!(f, "{:#x}", remaining)?;
4455        } else if first {
4456            f.write_str("(empty)")?;
4457        }
4458        Ok(())
4459    }
4460}
4461///[`VkDataGraphPipelineSessionCreateFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateFlagBitsARM.html)
4462#[repr(transparent)]
4463#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4464#[doc(alias = "VkDataGraphPipelineSessionCreateFlagBitsARM")]
4465pub struct DataGraphPipelineSessionCreateFlagBitsARM(u64);
4466impl DataGraphPipelineSessionCreateFlagBitsARM {
4467    #[inline]
4468    pub const fn empty() -> Self {
4469        Self(0u64)
4470    }
4471    #[inline]
4472    pub const fn from_raw(value: u64) -> Self {
4473        Self(value)
4474    }
4475    #[inline]
4476    pub const fn as_raw(self) -> u64 {
4477        self.0
4478    }
4479    #[inline]
4480    pub const fn is_empty(self) -> bool {
4481        self.0 == 0u64
4482    }
4483    #[inline]
4484    pub const fn contains(self, other: Self) -> bool {
4485        (self.0 & other.0) == other.0
4486    }
4487    #[inline]
4488    pub const fn all() -> Self {
4489        Self(1u64)
4490    }
4491    ///Bit 0.
4492    pub const PROTECTED_BIT: Self = Self(1u64);
4493}
4494impl core::ops::BitOr for DataGraphPipelineSessionCreateFlagBitsARM {
4495    type Output = Self;
4496    #[inline]
4497    fn bitor(self, rhs: Self) -> Self {
4498        Self(self.0 | rhs.0)
4499    }
4500}
4501impl core::ops::BitOrAssign for DataGraphPipelineSessionCreateFlagBitsARM {
4502    #[inline]
4503    fn bitor_assign(&mut self, rhs: Self) {
4504        self.0 |= rhs.0;
4505    }
4506}
4507impl core::ops::BitAnd for DataGraphPipelineSessionCreateFlagBitsARM {
4508    type Output = Self;
4509    #[inline]
4510    fn bitand(self, rhs: Self) -> Self {
4511        Self(self.0 & rhs.0)
4512    }
4513}
4514impl core::ops::BitAndAssign for DataGraphPipelineSessionCreateFlagBitsARM {
4515    #[inline]
4516    fn bitand_assign(&mut self, rhs: Self) {
4517        self.0 &= rhs.0;
4518    }
4519}
4520impl core::ops::BitXor for DataGraphPipelineSessionCreateFlagBitsARM {
4521    type Output = Self;
4522    #[inline]
4523    fn bitxor(self, rhs: Self) -> Self {
4524        Self(self.0 ^ rhs.0)
4525    }
4526}
4527impl core::ops::BitXorAssign for DataGraphPipelineSessionCreateFlagBitsARM {
4528    #[inline]
4529    fn bitxor_assign(&mut self, rhs: Self) {
4530        self.0 ^= rhs.0;
4531    }
4532}
4533impl core::ops::Not for DataGraphPipelineSessionCreateFlagBitsARM {
4534    type Output = Self;
4535    #[inline]
4536    fn not(self) -> Self {
4537        Self(!self.0)
4538    }
4539}
4540impl core::fmt::Debug for DataGraphPipelineSessionCreateFlagBitsARM {
4541    #[allow(unused_mut, unused_variables)]
4542    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4543        let mut first = true;
4544        let mut remaining = self.0;
4545        if remaining & Self::PROTECTED_BIT.0 != 0 {
4546            if !first {
4547                f.write_str(" | ")?;
4548            }
4549            f.write_str("PROTECTED_BIT")?;
4550            remaining &= !Self::PROTECTED_BIT.0;
4551            first = false;
4552        }
4553        if remaining != 0u64 {
4554            if !first {
4555                f.write_str(" | ")?;
4556            }
4557            write!(f, "{:#x}", remaining)?;
4558        } else if first {
4559            f.write_str("(empty)")?;
4560        }
4561        Ok(())
4562    }
4563}
4564///[`VkDebugReportFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportFlagBitsEXT.html)
4565#[repr(transparent)]
4566#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4567#[doc(alias = "VkDebugReportFlagBitsEXT")]
4568pub struct DebugReportFlagBitsEXT(u32);
4569impl DebugReportFlagBitsEXT {
4570    #[inline]
4571    pub const fn empty() -> Self {
4572        Self(0u32)
4573    }
4574    #[inline]
4575    pub const fn from_raw(value: u32) -> Self {
4576        Self(value)
4577    }
4578    #[inline]
4579    pub const fn as_raw(self) -> u32 {
4580        self.0
4581    }
4582    #[inline]
4583    pub const fn is_empty(self) -> bool {
4584        self.0 == 0u32
4585    }
4586    #[inline]
4587    pub const fn contains(self, other: Self) -> bool {
4588        (self.0 & other.0) == other.0
4589    }
4590    #[inline]
4591    pub const fn all() -> Self {
4592        Self(31u32)
4593    }
4594    ///Bit 0.
4595    pub const INFORMATION: Self = Self(1u32);
4596    ///Bit 1.
4597    pub const WARNING: Self = Self(2u32);
4598    ///Bit 2.
4599    pub const PERFORMANCE_WARNING: Self = Self(4u32);
4600    ///Bit 3.
4601    pub const ERROR: Self = Self(8u32);
4602    ///Bit 4.
4603    pub const DEBUG: Self = Self(16u32);
4604}
4605impl core::ops::BitOr for DebugReportFlagBitsEXT {
4606    type Output = Self;
4607    #[inline]
4608    fn bitor(self, rhs: Self) -> Self {
4609        Self(self.0 | rhs.0)
4610    }
4611}
4612impl core::ops::BitOrAssign for DebugReportFlagBitsEXT {
4613    #[inline]
4614    fn bitor_assign(&mut self, rhs: Self) {
4615        self.0 |= rhs.0;
4616    }
4617}
4618impl core::ops::BitAnd for DebugReportFlagBitsEXT {
4619    type Output = Self;
4620    #[inline]
4621    fn bitand(self, rhs: Self) -> Self {
4622        Self(self.0 & rhs.0)
4623    }
4624}
4625impl core::ops::BitAndAssign for DebugReportFlagBitsEXT {
4626    #[inline]
4627    fn bitand_assign(&mut self, rhs: Self) {
4628        self.0 &= rhs.0;
4629    }
4630}
4631impl core::ops::BitXor for DebugReportFlagBitsEXT {
4632    type Output = Self;
4633    #[inline]
4634    fn bitxor(self, rhs: Self) -> Self {
4635        Self(self.0 ^ rhs.0)
4636    }
4637}
4638impl core::ops::BitXorAssign for DebugReportFlagBitsEXT {
4639    #[inline]
4640    fn bitxor_assign(&mut self, rhs: Self) {
4641        self.0 ^= rhs.0;
4642    }
4643}
4644impl core::ops::Not for DebugReportFlagBitsEXT {
4645    type Output = Self;
4646    #[inline]
4647    fn not(self) -> Self {
4648        Self(!self.0)
4649    }
4650}
4651impl core::fmt::Debug for DebugReportFlagBitsEXT {
4652    #[allow(unused_mut, unused_variables)]
4653    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4654        let mut first = true;
4655        let mut remaining = self.0;
4656        if remaining & Self::INFORMATION.0 != 0 {
4657            if !first {
4658                f.write_str(" | ")?;
4659            }
4660            f.write_str("INFORMATION")?;
4661            remaining &= !Self::INFORMATION.0;
4662            first = false;
4663        }
4664        if remaining & Self::WARNING.0 != 0 {
4665            if !first {
4666                f.write_str(" | ")?;
4667            }
4668            f.write_str("WARNING")?;
4669            remaining &= !Self::WARNING.0;
4670            first = false;
4671        }
4672        if remaining & Self::PERFORMANCE_WARNING.0 != 0 {
4673            if !first {
4674                f.write_str(" | ")?;
4675            }
4676            f.write_str("PERFORMANCE_WARNING")?;
4677            remaining &= !Self::PERFORMANCE_WARNING.0;
4678            first = false;
4679        }
4680        if remaining & Self::ERROR.0 != 0 {
4681            if !first {
4682                f.write_str(" | ")?;
4683            }
4684            f.write_str("ERROR")?;
4685            remaining &= !Self::ERROR.0;
4686            first = false;
4687        }
4688        if remaining & Self::DEBUG.0 != 0 {
4689            if !first {
4690                f.write_str(" | ")?;
4691            }
4692            f.write_str("DEBUG")?;
4693            remaining &= !Self::DEBUG.0;
4694            first = false;
4695        }
4696        if remaining != 0u32 {
4697            if !first {
4698                f.write_str(" | ")?;
4699            }
4700            write!(f, "{:#x}", remaining)?;
4701        } else if first {
4702            f.write_str("(empty)")?;
4703        }
4704        Ok(())
4705    }
4706}
4707///[`VkDebugUtilsMessageSeverityFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html)
4708#[repr(transparent)]
4709#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4710#[doc(alias = "VkDebugUtilsMessageSeverityFlagBitsEXT")]
4711pub struct DebugUtilsMessageSeverityFlagBitsEXT(u32);
4712impl DebugUtilsMessageSeverityFlagBitsEXT {
4713    #[inline]
4714    pub const fn empty() -> Self {
4715        Self(0u32)
4716    }
4717    #[inline]
4718    pub const fn from_raw(value: u32) -> Self {
4719        Self(value)
4720    }
4721    #[inline]
4722    pub const fn as_raw(self) -> u32 {
4723        self.0
4724    }
4725    #[inline]
4726    pub const fn is_empty(self) -> bool {
4727        self.0 == 0u32
4728    }
4729    #[inline]
4730    pub const fn contains(self, other: Self) -> bool {
4731        (self.0 & other.0) == other.0
4732    }
4733    #[inline]
4734    pub const fn all() -> Self {
4735        Self(4369u32)
4736    }
4737    ///Bit 0.
4738    pub const VERBOSE: Self = Self(1u32);
4739    ///Bit 4.
4740    pub const INFO: Self = Self(16u32);
4741    ///Bit 8.
4742    pub const WARNING: Self = Self(256u32);
4743    ///Bit 12.
4744    pub const ERROR: Self = Self(4096u32);
4745}
4746impl core::ops::BitOr for DebugUtilsMessageSeverityFlagBitsEXT {
4747    type Output = Self;
4748    #[inline]
4749    fn bitor(self, rhs: Self) -> Self {
4750        Self(self.0 | rhs.0)
4751    }
4752}
4753impl core::ops::BitOrAssign for DebugUtilsMessageSeverityFlagBitsEXT {
4754    #[inline]
4755    fn bitor_assign(&mut self, rhs: Self) {
4756        self.0 |= rhs.0;
4757    }
4758}
4759impl core::ops::BitAnd for DebugUtilsMessageSeverityFlagBitsEXT {
4760    type Output = Self;
4761    #[inline]
4762    fn bitand(self, rhs: Self) -> Self {
4763        Self(self.0 & rhs.0)
4764    }
4765}
4766impl core::ops::BitAndAssign for DebugUtilsMessageSeverityFlagBitsEXT {
4767    #[inline]
4768    fn bitand_assign(&mut self, rhs: Self) {
4769        self.0 &= rhs.0;
4770    }
4771}
4772impl core::ops::BitXor for DebugUtilsMessageSeverityFlagBitsEXT {
4773    type Output = Self;
4774    #[inline]
4775    fn bitxor(self, rhs: Self) -> Self {
4776        Self(self.0 ^ rhs.0)
4777    }
4778}
4779impl core::ops::BitXorAssign for DebugUtilsMessageSeverityFlagBitsEXT {
4780    #[inline]
4781    fn bitxor_assign(&mut self, rhs: Self) {
4782        self.0 ^= rhs.0;
4783    }
4784}
4785impl core::ops::Not for DebugUtilsMessageSeverityFlagBitsEXT {
4786    type Output = Self;
4787    #[inline]
4788    fn not(self) -> Self {
4789        Self(!self.0)
4790    }
4791}
4792impl core::fmt::Debug for DebugUtilsMessageSeverityFlagBitsEXT {
4793    #[allow(unused_mut, unused_variables)]
4794    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4795        let mut first = true;
4796        let mut remaining = self.0;
4797        if remaining & Self::VERBOSE.0 != 0 {
4798            if !first {
4799                f.write_str(" | ")?;
4800            }
4801            f.write_str("VERBOSE")?;
4802            remaining &= !Self::VERBOSE.0;
4803            first = false;
4804        }
4805        if remaining & Self::INFO.0 != 0 {
4806            if !first {
4807                f.write_str(" | ")?;
4808            }
4809            f.write_str("INFO")?;
4810            remaining &= !Self::INFO.0;
4811            first = false;
4812        }
4813        if remaining & Self::WARNING.0 != 0 {
4814            if !first {
4815                f.write_str(" | ")?;
4816            }
4817            f.write_str("WARNING")?;
4818            remaining &= !Self::WARNING.0;
4819            first = false;
4820        }
4821        if remaining & Self::ERROR.0 != 0 {
4822            if !first {
4823                f.write_str(" | ")?;
4824            }
4825            f.write_str("ERROR")?;
4826            remaining &= !Self::ERROR.0;
4827            first = false;
4828        }
4829        if remaining != 0u32 {
4830            if !first {
4831                f.write_str(" | ")?;
4832            }
4833            write!(f, "{:#x}", remaining)?;
4834        } else if first {
4835            f.write_str("(empty)")?;
4836        }
4837        Ok(())
4838    }
4839}
4840///[`VkDebugUtilsMessageTypeFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html)
4841#[repr(transparent)]
4842#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4843#[doc(alias = "VkDebugUtilsMessageTypeFlagBitsEXT")]
4844pub struct DebugUtilsMessageTypeFlagBitsEXT(u32);
4845impl DebugUtilsMessageTypeFlagBitsEXT {
4846    #[inline]
4847    pub const fn empty() -> Self {
4848        Self(0u32)
4849    }
4850    #[inline]
4851    pub const fn from_raw(value: u32) -> Self {
4852        Self(value)
4853    }
4854    #[inline]
4855    pub const fn as_raw(self) -> u32 {
4856        self.0
4857    }
4858    #[inline]
4859    pub const fn is_empty(self) -> bool {
4860        self.0 == 0u32
4861    }
4862    #[inline]
4863    pub const fn contains(self, other: Self) -> bool {
4864        (self.0 & other.0) == other.0
4865    }
4866    #[inline]
4867    pub const fn all() -> Self {
4868        Self(15u32)
4869    }
4870    ///Bit 0.
4871    pub const GENERAL: Self = Self(1u32);
4872    ///Bit 1.
4873    pub const VALIDATION: Self = Self(2u32);
4874    ///Bit 2.
4875    pub const PERFORMANCE: Self = Self(4u32);
4876    ///Bit 3.
4877    pub const DEVICE_ADDRESS_BINDING: Self = Self(8u32);
4878}
4879impl core::ops::BitOr for DebugUtilsMessageTypeFlagBitsEXT {
4880    type Output = Self;
4881    #[inline]
4882    fn bitor(self, rhs: Self) -> Self {
4883        Self(self.0 | rhs.0)
4884    }
4885}
4886impl core::ops::BitOrAssign for DebugUtilsMessageTypeFlagBitsEXT {
4887    #[inline]
4888    fn bitor_assign(&mut self, rhs: Self) {
4889        self.0 |= rhs.0;
4890    }
4891}
4892impl core::ops::BitAnd for DebugUtilsMessageTypeFlagBitsEXT {
4893    type Output = Self;
4894    #[inline]
4895    fn bitand(self, rhs: Self) -> Self {
4896        Self(self.0 & rhs.0)
4897    }
4898}
4899impl core::ops::BitAndAssign for DebugUtilsMessageTypeFlagBitsEXT {
4900    #[inline]
4901    fn bitand_assign(&mut self, rhs: Self) {
4902        self.0 &= rhs.0;
4903    }
4904}
4905impl core::ops::BitXor for DebugUtilsMessageTypeFlagBitsEXT {
4906    type Output = Self;
4907    #[inline]
4908    fn bitxor(self, rhs: Self) -> Self {
4909        Self(self.0 ^ rhs.0)
4910    }
4911}
4912impl core::ops::BitXorAssign for DebugUtilsMessageTypeFlagBitsEXT {
4913    #[inline]
4914    fn bitxor_assign(&mut self, rhs: Self) {
4915        self.0 ^= rhs.0;
4916    }
4917}
4918impl core::ops::Not for DebugUtilsMessageTypeFlagBitsEXT {
4919    type Output = Self;
4920    #[inline]
4921    fn not(self) -> Self {
4922        Self(!self.0)
4923    }
4924}
4925impl core::fmt::Debug for DebugUtilsMessageTypeFlagBitsEXT {
4926    #[allow(unused_mut, unused_variables)]
4927    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4928        let mut first = true;
4929        let mut remaining = self.0;
4930        if remaining & Self::GENERAL.0 != 0 {
4931            if !first {
4932                f.write_str(" | ")?;
4933            }
4934            f.write_str("GENERAL")?;
4935            remaining &= !Self::GENERAL.0;
4936            first = false;
4937        }
4938        if remaining & Self::VALIDATION.0 != 0 {
4939            if !first {
4940                f.write_str(" | ")?;
4941            }
4942            f.write_str("VALIDATION")?;
4943            remaining &= !Self::VALIDATION.0;
4944            first = false;
4945        }
4946        if remaining & Self::PERFORMANCE.0 != 0 {
4947            if !first {
4948                f.write_str(" | ")?;
4949            }
4950            f.write_str("PERFORMANCE")?;
4951            remaining &= !Self::PERFORMANCE.0;
4952            first = false;
4953        }
4954        if remaining & Self::DEVICE_ADDRESS_BINDING.0 != 0 {
4955            if !first {
4956                f.write_str(" | ")?;
4957            }
4958            f.write_str("DEVICE_ADDRESS_BINDING")?;
4959            remaining &= !Self::DEVICE_ADDRESS_BINDING.0;
4960            first = false;
4961        }
4962        if remaining != 0u32 {
4963            if !first {
4964                f.write_str(" | ")?;
4965            }
4966            write!(f, "{:#x}", remaining)?;
4967        } else if first {
4968            f.write_str("(empty)")?;
4969        }
4970        Ok(())
4971    }
4972}
4973///[`VkDependencyFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyFlagBits.html)
4974#[repr(transparent)]
4975#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4976#[doc(alias = "VkDependencyFlagBits")]
4977pub struct DependencyFlagBits(u32);
4978impl DependencyFlagBits {
4979    #[inline]
4980    pub const fn empty() -> Self {
4981        Self(0u32)
4982    }
4983    #[inline]
4984    pub const fn from_raw(value: u32) -> Self {
4985        Self(value)
4986    }
4987    #[inline]
4988    pub const fn as_raw(self) -> u32 {
4989        self.0
4990    }
4991    #[inline]
4992    pub const fn is_empty(self) -> bool {
4993        self.0 == 0u32
4994    }
4995    #[inline]
4996    pub const fn contains(self, other: Self) -> bool {
4997        (self.0 & other.0) == other.0
4998    }
4999    #[inline]
5000    pub const fn all() -> Self {
5001        Self(111u32)
5002    }
5003    ///Bit 0.
5004    pub const BY_REGION: Self = Self(1u32);
5005    ///Bit 2.
5006    pub const DEVICE_GROUP: Self = Self(4u32);
5007    ///Bit 1.
5008    pub const VIEW_LOCAL: Self = Self(2u32);
5009    ///Bit 3.
5010    pub const FEEDBACK_LOOP: Self = Self(8u32);
5011    ///Bit 5.
5012    pub const QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES: Self = Self(32u32);
5013    ///Bit 6.
5014    pub const ASYMMETRIC_EVENT: Self = Self(64u32);
5015}
5016impl core::ops::BitOr for DependencyFlagBits {
5017    type Output = Self;
5018    #[inline]
5019    fn bitor(self, rhs: Self) -> Self {
5020        Self(self.0 | rhs.0)
5021    }
5022}
5023impl core::ops::BitOrAssign for DependencyFlagBits {
5024    #[inline]
5025    fn bitor_assign(&mut self, rhs: Self) {
5026        self.0 |= rhs.0;
5027    }
5028}
5029impl core::ops::BitAnd for DependencyFlagBits {
5030    type Output = Self;
5031    #[inline]
5032    fn bitand(self, rhs: Self) -> Self {
5033        Self(self.0 & rhs.0)
5034    }
5035}
5036impl core::ops::BitAndAssign for DependencyFlagBits {
5037    #[inline]
5038    fn bitand_assign(&mut self, rhs: Self) {
5039        self.0 &= rhs.0;
5040    }
5041}
5042impl core::ops::BitXor for DependencyFlagBits {
5043    type Output = Self;
5044    #[inline]
5045    fn bitxor(self, rhs: Self) -> Self {
5046        Self(self.0 ^ rhs.0)
5047    }
5048}
5049impl core::ops::BitXorAssign for DependencyFlagBits {
5050    #[inline]
5051    fn bitxor_assign(&mut self, rhs: Self) {
5052        self.0 ^= rhs.0;
5053    }
5054}
5055impl core::ops::Not for DependencyFlagBits {
5056    type Output = Self;
5057    #[inline]
5058    fn not(self) -> Self {
5059        Self(!self.0)
5060    }
5061}
5062impl core::fmt::Debug for DependencyFlagBits {
5063    #[allow(unused_mut, unused_variables)]
5064    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5065        let mut first = true;
5066        let mut remaining = self.0;
5067        if remaining & Self::BY_REGION.0 != 0 {
5068            if !first {
5069                f.write_str(" | ")?;
5070            }
5071            f.write_str("BY_REGION")?;
5072            remaining &= !Self::BY_REGION.0;
5073            first = false;
5074        }
5075        if remaining & Self::DEVICE_GROUP.0 != 0 {
5076            if !first {
5077                f.write_str(" | ")?;
5078            }
5079            f.write_str("DEVICE_GROUP")?;
5080            remaining &= !Self::DEVICE_GROUP.0;
5081            first = false;
5082        }
5083        if remaining & Self::VIEW_LOCAL.0 != 0 {
5084            if !first {
5085                f.write_str(" | ")?;
5086            }
5087            f.write_str("VIEW_LOCAL")?;
5088            remaining &= !Self::VIEW_LOCAL.0;
5089            first = false;
5090        }
5091        if remaining & Self::FEEDBACK_LOOP.0 != 0 {
5092            if !first {
5093                f.write_str(" | ")?;
5094            }
5095            f.write_str("FEEDBACK_LOOP")?;
5096            remaining &= !Self::FEEDBACK_LOOP.0;
5097            first = false;
5098        }
5099        if remaining & Self::QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES.0 != 0 {
5100            if !first {
5101                f.write_str(" | ")?;
5102            }
5103            f.write_str("QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES")?;
5104            remaining &= !Self::QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES.0;
5105            first = false;
5106        }
5107        if remaining & Self::ASYMMETRIC_EVENT.0 != 0 {
5108            if !first {
5109                f.write_str(" | ")?;
5110            }
5111            f.write_str("ASYMMETRIC_EVENT")?;
5112            remaining &= !Self::ASYMMETRIC_EVENT.0;
5113            first = false;
5114        }
5115        if remaining != 0u32 {
5116            if !first {
5117                f.write_str(" | ")?;
5118            }
5119            write!(f, "{:#x}", remaining)?;
5120        } else if first {
5121            f.write_str("(empty)")?;
5122        }
5123        Ok(())
5124    }
5125}
5126///[`VkDescriptorBindingFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBindingFlagBits.html)
5127#[repr(transparent)]
5128#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5129#[doc(alias = "VkDescriptorBindingFlagBits")]
5130pub struct DescriptorBindingFlagBits(u32);
5131impl DescriptorBindingFlagBits {
5132    #[inline]
5133    pub const fn empty() -> Self {
5134        Self(0u32)
5135    }
5136    #[inline]
5137    pub const fn from_raw(value: u32) -> Self {
5138        Self(value)
5139    }
5140    #[inline]
5141    pub const fn as_raw(self) -> u32 {
5142        self.0
5143    }
5144    #[inline]
5145    pub const fn is_empty(self) -> bool {
5146        self.0 == 0u32
5147    }
5148    #[inline]
5149    pub const fn contains(self, other: Self) -> bool {
5150        (self.0 & other.0) == other.0
5151    }
5152    #[inline]
5153    pub const fn all() -> Self {
5154        Self(15u32)
5155    }
5156    ///Bit 0.
5157    pub const UPDATE_AFTER_BIND: Self = Self(1u32);
5158    ///Bit 1.
5159    pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(2u32);
5160    ///Bit 2.
5161    pub const PARTIALLY_BOUND: Self = Self(4u32);
5162    ///Bit 3.
5163    pub const VARIABLE_DESCRIPTOR_COUNT: Self = Self(8u32);
5164}
5165impl core::ops::BitOr for DescriptorBindingFlagBits {
5166    type Output = Self;
5167    #[inline]
5168    fn bitor(self, rhs: Self) -> Self {
5169        Self(self.0 | rhs.0)
5170    }
5171}
5172impl core::ops::BitOrAssign for DescriptorBindingFlagBits {
5173    #[inline]
5174    fn bitor_assign(&mut self, rhs: Self) {
5175        self.0 |= rhs.0;
5176    }
5177}
5178impl core::ops::BitAnd for DescriptorBindingFlagBits {
5179    type Output = Self;
5180    #[inline]
5181    fn bitand(self, rhs: Self) -> Self {
5182        Self(self.0 & rhs.0)
5183    }
5184}
5185impl core::ops::BitAndAssign for DescriptorBindingFlagBits {
5186    #[inline]
5187    fn bitand_assign(&mut self, rhs: Self) {
5188        self.0 &= rhs.0;
5189    }
5190}
5191impl core::ops::BitXor for DescriptorBindingFlagBits {
5192    type Output = Self;
5193    #[inline]
5194    fn bitxor(self, rhs: Self) -> Self {
5195        Self(self.0 ^ rhs.0)
5196    }
5197}
5198impl core::ops::BitXorAssign for DescriptorBindingFlagBits {
5199    #[inline]
5200    fn bitxor_assign(&mut self, rhs: Self) {
5201        self.0 ^= rhs.0;
5202    }
5203}
5204impl core::ops::Not for DescriptorBindingFlagBits {
5205    type Output = Self;
5206    #[inline]
5207    fn not(self) -> Self {
5208        Self(!self.0)
5209    }
5210}
5211impl core::fmt::Debug for DescriptorBindingFlagBits {
5212    #[allow(unused_mut, unused_variables)]
5213    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5214        let mut first = true;
5215        let mut remaining = self.0;
5216        if remaining & Self::UPDATE_AFTER_BIND.0 != 0 {
5217            if !first {
5218                f.write_str(" | ")?;
5219            }
5220            f.write_str("UPDATE_AFTER_BIND")?;
5221            remaining &= !Self::UPDATE_AFTER_BIND.0;
5222            first = false;
5223        }
5224        if remaining & Self::UPDATE_UNUSED_WHILE_PENDING.0 != 0 {
5225            if !first {
5226                f.write_str(" | ")?;
5227            }
5228            f.write_str("UPDATE_UNUSED_WHILE_PENDING")?;
5229            remaining &= !Self::UPDATE_UNUSED_WHILE_PENDING.0;
5230            first = false;
5231        }
5232        if remaining & Self::PARTIALLY_BOUND.0 != 0 {
5233            if !first {
5234                f.write_str(" | ")?;
5235            }
5236            f.write_str("PARTIALLY_BOUND")?;
5237            remaining &= !Self::PARTIALLY_BOUND.0;
5238            first = false;
5239        }
5240        if remaining & Self::VARIABLE_DESCRIPTOR_COUNT.0 != 0 {
5241            if !first {
5242                f.write_str(" | ")?;
5243            }
5244            f.write_str("VARIABLE_DESCRIPTOR_COUNT")?;
5245            remaining &= !Self::VARIABLE_DESCRIPTOR_COUNT.0;
5246            first = false;
5247        }
5248        if remaining != 0u32 {
5249            if !first {
5250                f.write_str(" | ")?;
5251            }
5252            write!(f, "{:#x}", remaining)?;
5253        } else if first {
5254            f.write_str("(empty)")?;
5255        }
5256        Ok(())
5257    }
5258}
5259///[`VkDescriptorPoolCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateFlagBits.html)
5260#[repr(transparent)]
5261#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5262#[doc(alias = "VkDescriptorPoolCreateFlagBits")]
5263pub struct DescriptorPoolCreateFlagBits(u32);
5264impl DescriptorPoolCreateFlagBits {
5265    #[inline]
5266    pub const fn empty() -> Self {
5267        Self(0u32)
5268    }
5269    #[inline]
5270    pub const fn from_raw(value: u32) -> Self {
5271        Self(value)
5272    }
5273    #[inline]
5274    pub const fn as_raw(self) -> u32 {
5275        self.0
5276    }
5277    #[inline]
5278    pub const fn is_empty(self) -> bool {
5279        self.0 == 0u32
5280    }
5281    #[inline]
5282    pub const fn contains(self, other: Self) -> bool {
5283        (self.0 & other.0) == other.0
5284    }
5285    #[inline]
5286    pub const fn all() -> Self {
5287        Self(31u32)
5288    }
5289    ///Bit 0.
5290    pub const FREE_DESCRIPTOR_SET: Self = Self(1u32);
5291    ///Bit 1.
5292    pub const UPDATE_AFTER_BIND: Self = Self(2u32);
5293    pub const HOST_ONLY_BIT: Self = Self::HOST_ONLY;
5294    ///Bit 2.
5295    pub const HOST_ONLY: Self = Self(4u32);
5296    ///Bit 3.
5297    pub const ALLOW_OVERALLOCATION_SETS: Self = Self(8u32);
5298    ///Bit 4.
5299    pub const ALLOW_OVERALLOCATION_POOLS: Self = Self(16u32);
5300}
5301impl core::ops::BitOr for DescriptorPoolCreateFlagBits {
5302    type Output = Self;
5303    #[inline]
5304    fn bitor(self, rhs: Self) -> Self {
5305        Self(self.0 | rhs.0)
5306    }
5307}
5308impl core::ops::BitOrAssign for DescriptorPoolCreateFlagBits {
5309    #[inline]
5310    fn bitor_assign(&mut self, rhs: Self) {
5311        self.0 |= rhs.0;
5312    }
5313}
5314impl core::ops::BitAnd for DescriptorPoolCreateFlagBits {
5315    type Output = Self;
5316    #[inline]
5317    fn bitand(self, rhs: Self) -> Self {
5318        Self(self.0 & rhs.0)
5319    }
5320}
5321impl core::ops::BitAndAssign for DescriptorPoolCreateFlagBits {
5322    #[inline]
5323    fn bitand_assign(&mut self, rhs: Self) {
5324        self.0 &= rhs.0;
5325    }
5326}
5327impl core::ops::BitXor for DescriptorPoolCreateFlagBits {
5328    type Output = Self;
5329    #[inline]
5330    fn bitxor(self, rhs: Self) -> Self {
5331        Self(self.0 ^ rhs.0)
5332    }
5333}
5334impl core::ops::BitXorAssign for DescriptorPoolCreateFlagBits {
5335    #[inline]
5336    fn bitxor_assign(&mut self, rhs: Self) {
5337        self.0 ^= rhs.0;
5338    }
5339}
5340impl core::ops::Not for DescriptorPoolCreateFlagBits {
5341    type Output = Self;
5342    #[inline]
5343    fn not(self) -> Self {
5344        Self(!self.0)
5345    }
5346}
5347impl core::fmt::Debug for DescriptorPoolCreateFlagBits {
5348    #[allow(unused_mut, unused_variables)]
5349    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5350        let mut first = true;
5351        let mut remaining = self.0;
5352        if remaining & Self::FREE_DESCRIPTOR_SET.0 != 0 {
5353            if !first {
5354                f.write_str(" | ")?;
5355            }
5356            f.write_str("FREE_DESCRIPTOR_SET")?;
5357            remaining &= !Self::FREE_DESCRIPTOR_SET.0;
5358            first = false;
5359        }
5360        if remaining & Self::UPDATE_AFTER_BIND.0 != 0 {
5361            if !first {
5362                f.write_str(" | ")?;
5363            }
5364            f.write_str("UPDATE_AFTER_BIND")?;
5365            remaining &= !Self::UPDATE_AFTER_BIND.0;
5366            first = false;
5367        }
5368        if remaining & Self::HOST_ONLY.0 != 0 {
5369            if !first {
5370                f.write_str(" | ")?;
5371            }
5372            f.write_str("HOST_ONLY")?;
5373            remaining &= !Self::HOST_ONLY.0;
5374            first = false;
5375        }
5376        if remaining & Self::ALLOW_OVERALLOCATION_SETS.0 != 0 {
5377            if !first {
5378                f.write_str(" | ")?;
5379            }
5380            f.write_str("ALLOW_OVERALLOCATION_SETS")?;
5381            remaining &= !Self::ALLOW_OVERALLOCATION_SETS.0;
5382            first = false;
5383        }
5384        if remaining & Self::ALLOW_OVERALLOCATION_POOLS.0 != 0 {
5385            if !first {
5386                f.write_str(" | ")?;
5387            }
5388            f.write_str("ALLOW_OVERALLOCATION_POOLS")?;
5389            remaining &= !Self::ALLOW_OVERALLOCATION_POOLS.0;
5390            first = false;
5391        }
5392        if remaining != 0u32 {
5393            if !first {
5394                f.write_str(" | ")?;
5395            }
5396            write!(f, "{:#x}", remaining)?;
5397        } else if first {
5398            f.write_str("(empty)")?;
5399        }
5400        Ok(())
5401    }
5402}
5403///[`VkDescriptorSetLayoutCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateFlagBits.html)
5404#[repr(transparent)]
5405#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5406#[doc(alias = "VkDescriptorSetLayoutCreateFlagBits")]
5407pub struct DescriptorSetLayoutCreateFlagBits(u32);
5408impl DescriptorSetLayoutCreateFlagBits {
5409    #[inline]
5410    pub const fn empty() -> Self {
5411        Self(0u32)
5412    }
5413    #[inline]
5414    pub const fn from_raw(value: u32) -> Self {
5415        Self(value)
5416    }
5417    #[inline]
5418    pub const fn as_raw(self) -> u32 {
5419        self.0
5420    }
5421    #[inline]
5422    pub const fn is_empty(self) -> bool {
5423        self.0 == 0u32
5424    }
5425    #[inline]
5426    pub const fn contains(self, other: Self) -> bool {
5427        (self.0 & other.0) == other.0
5428    }
5429    #[inline]
5430    pub const fn all() -> Self {
5431        Self(247u32)
5432    }
5433    ///Bit 1.
5434    pub const UPDATE_AFTER_BIND_POOL: Self = Self(2u32);
5435    ///Bit 0.
5436    pub const PUSH_DESCRIPTOR: Self = Self(1u32);
5437    ///Bit 4.
5438    pub const DESCRIPTOR_BUFFER: Self = Self(16u32);
5439    ///Bit 5.
5440    pub const EMBEDDED_IMMUTABLE_SAMPLERS: Self = Self(32u32);
5441    pub const HOST_ONLY_POOL_BIT: Self = Self::HOST_ONLY_POOL;
5442    ///Bit 7.
5443    pub const INDIRECT_BINDABLE: Self = Self(128u32);
5444    ///Bit 2.
5445    pub const HOST_ONLY_POOL: Self = Self(4u32);
5446    ///Bit 6.
5447    pub const PER_STAGE: Self = Self(64u32);
5448}
5449impl core::ops::BitOr for DescriptorSetLayoutCreateFlagBits {
5450    type Output = Self;
5451    #[inline]
5452    fn bitor(self, rhs: Self) -> Self {
5453        Self(self.0 | rhs.0)
5454    }
5455}
5456impl core::ops::BitOrAssign for DescriptorSetLayoutCreateFlagBits {
5457    #[inline]
5458    fn bitor_assign(&mut self, rhs: Self) {
5459        self.0 |= rhs.0;
5460    }
5461}
5462impl core::ops::BitAnd for DescriptorSetLayoutCreateFlagBits {
5463    type Output = Self;
5464    #[inline]
5465    fn bitand(self, rhs: Self) -> Self {
5466        Self(self.0 & rhs.0)
5467    }
5468}
5469impl core::ops::BitAndAssign for DescriptorSetLayoutCreateFlagBits {
5470    #[inline]
5471    fn bitand_assign(&mut self, rhs: Self) {
5472        self.0 &= rhs.0;
5473    }
5474}
5475impl core::ops::BitXor for DescriptorSetLayoutCreateFlagBits {
5476    type Output = Self;
5477    #[inline]
5478    fn bitxor(self, rhs: Self) -> Self {
5479        Self(self.0 ^ rhs.0)
5480    }
5481}
5482impl core::ops::BitXorAssign for DescriptorSetLayoutCreateFlagBits {
5483    #[inline]
5484    fn bitxor_assign(&mut self, rhs: Self) {
5485        self.0 ^= rhs.0;
5486    }
5487}
5488impl core::ops::Not for DescriptorSetLayoutCreateFlagBits {
5489    type Output = Self;
5490    #[inline]
5491    fn not(self) -> Self {
5492        Self(!self.0)
5493    }
5494}
5495impl core::fmt::Debug for DescriptorSetLayoutCreateFlagBits {
5496    #[allow(unused_mut, unused_variables)]
5497    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5498        let mut first = true;
5499        let mut remaining = self.0;
5500        if remaining & Self::UPDATE_AFTER_BIND_POOL.0 != 0 {
5501            if !first {
5502                f.write_str(" | ")?;
5503            }
5504            f.write_str("UPDATE_AFTER_BIND_POOL")?;
5505            remaining &= !Self::UPDATE_AFTER_BIND_POOL.0;
5506            first = false;
5507        }
5508        if remaining & Self::PUSH_DESCRIPTOR.0 != 0 {
5509            if !first {
5510                f.write_str(" | ")?;
5511            }
5512            f.write_str("PUSH_DESCRIPTOR")?;
5513            remaining &= !Self::PUSH_DESCRIPTOR.0;
5514            first = false;
5515        }
5516        if remaining & Self::DESCRIPTOR_BUFFER.0 != 0 {
5517            if !first {
5518                f.write_str(" | ")?;
5519            }
5520            f.write_str("DESCRIPTOR_BUFFER")?;
5521            remaining &= !Self::DESCRIPTOR_BUFFER.0;
5522            first = false;
5523        }
5524        if remaining & Self::EMBEDDED_IMMUTABLE_SAMPLERS.0 != 0 {
5525            if !first {
5526                f.write_str(" | ")?;
5527            }
5528            f.write_str("EMBEDDED_IMMUTABLE_SAMPLERS")?;
5529            remaining &= !Self::EMBEDDED_IMMUTABLE_SAMPLERS.0;
5530            first = false;
5531        }
5532        if remaining & Self::INDIRECT_BINDABLE.0 != 0 {
5533            if !first {
5534                f.write_str(" | ")?;
5535            }
5536            f.write_str("INDIRECT_BINDABLE")?;
5537            remaining &= !Self::INDIRECT_BINDABLE.0;
5538            first = false;
5539        }
5540        if remaining & Self::HOST_ONLY_POOL.0 != 0 {
5541            if !first {
5542                f.write_str(" | ")?;
5543            }
5544            f.write_str("HOST_ONLY_POOL")?;
5545            remaining &= !Self::HOST_ONLY_POOL.0;
5546            first = false;
5547        }
5548        if remaining & Self::PER_STAGE.0 != 0 {
5549            if !first {
5550                f.write_str(" | ")?;
5551            }
5552            f.write_str("PER_STAGE")?;
5553            remaining &= !Self::PER_STAGE.0;
5554            first = false;
5555        }
5556        if remaining != 0u32 {
5557            if !first {
5558                f.write_str(" | ")?;
5559            }
5560            write!(f, "{:#x}", remaining)?;
5561        } else if first {
5562            f.write_str("(empty)")?;
5563        }
5564        Ok(())
5565    }
5566}
5567///[`VkDeviceAddressBindingFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingFlagBitsEXT.html)
5568#[repr(transparent)]
5569#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5570#[doc(alias = "VkDeviceAddressBindingFlagBitsEXT")]
5571pub struct DeviceAddressBindingFlagBitsEXT(u32);
5572impl DeviceAddressBindingFlagBitsEXT {
5573    #[inline]
5574    pub const fn empty() -> Self {
5575        Self(0u32)
5576    }
5577    #[inline]
5578    pub const fn from_raw(value: u32) -> Self {
5579        Self(value)
5580    }
5581    #[inline]
5582    pub const fn as_raw(self) -> u32 {
5583        self.0
5584    }
5585    #[inline]
5586    pub const fn is_empty(self) -> bool {
5587        self.0 == 0u32
5588    }
5589    #[inline]
5590    pub const fn contains(self, other: Self) -> bool {
5591        (self.0 & other.0) == other.0
5592    }
5593    #[inline]
5594    pub const fn all() -> Self {
5595        Self(1u32)
5596    }
5597    ///Bit 0.
5598    pub const INTERNAL_OBJECT: Self = Self(1u32);
5599}
5600impl core::ops::BitOr for DeviceAddressBindingFlagBitsEXT {
5601    type Output = Self;
5602    #[inline]
5603    fn bitor(self, rhs: Self) -> Self {
5604        Self(self.0 | rhs.0)
5605    }
5606}
5607impl core::ops::BitOrAssign for DeviceAddressBindingFlagBitsEXT {
5608    #[inline]
5609    fn bitor_assign(&mut self, rhs: Self) {
5610        self.0 |= rhs.0;
5611    }
5612}
5613impl core::ops::BitAnd for DeviceAddressBindingFlagBitsEXT {
5614    type Output = Self;
5615    #[inline]
5616    fn bitand(self, rhs: Self) -> Self {
5617        Self(self.0 & rhs.0)
5618    }
5619}
5620impl core::ops::BitAndAssign for DeviceAddressBindingFlagBitsEXT {
5621    #[inline]
5622    fn bitand_assign(&mut self, rhs: Self) {
5623        self.0 &= rhs.0;
5624    }
5625}
5626impl core::ops::BitXor for DeviceAddressBindingFlagBitsEXT {
5627    type Output = Self;
5628    #[inline]
5629    fn bitxor(self, rhs: Self) -> Self {
5630        Self(self.0 ^ rhs.0)
5631    }
5632}
5633impl core::ops::BitXorAssign for DeviceAddressBindingFlagBitsEXT {
5634    #[inline]
5635    fn bitxor_assign(&mut self, rhs: Self) {
5636        self.0 ^= rhs.0;
5637    }
5638}
5639impl core::ops::Not for DeviceAddressBindingFlagBitsEXT {
5640    type Output = Self;
5641    #[inline]
5642    fn not(self) -> Self {
5643        Self(!self.0)
5644    }
5645}
5646impl core::fmt::Debug for DeviceAddressBindingFlagBitsEXT {
5647    #[allow(unused_mut, unused_variables)]
5648    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5649        let mut first = true;
5650        let mut remaining = self.0;
5651        if remaining & Self::INTERNAL_OBJECT.0 != 0 {
5652            if !first {
5653                f.write_str(" | ")?;
5654            }
5655            f.write_str("INTERNAL_OBJECT")?;
5656            remaining &= !Self::INTERNAL_OBJECT.0;
5657            first = false;
5658        }
5659        if remaining != 0u32 {
5660            if !first {
5661                f.write_str(" | ")?;
5662            }
5663            write!(f, "{:#x}", remaining)?;
5664        } else if first {
5665            f.write_str("(empty)")?;
5666        }
5667        Ok(())
5668    }
5669}
5670///[`VkDeviceDiagnosticsConfigFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html)
5671#[repr(transparent)]
5672#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5673#[doc(alias = "VkDeviceDiagnosticsConfigFlagBitsNV")]
5674pub struct DeviceDiagnosticsConfigFlagBitsNV(u32);
5675impl DeviceDiagnosticsConfigFlagBitsNV {
5676    #[inline]
5677    pub const fn empty() -> Self {
5678        Self(0u32)
5679    }
5680    #[inline]
5681    pub const fn from_raw(value: u32) -> Self {
5682        Self(value)
5683    }
5684    #[inline]
5685    pub const fn as_raw(self) -> u32 {
5686        self.0
5687    }
5688    #[inline]
5689    pub const fn is_empty(self) -> bool {
5690        self.0 == 0u32
5691    }
5692    #[inline]
5693    pub const fn contains(self, other: Self) -> bool {
5694        (self.0 & other.0) == other.0
5695    }
5696    #[inline]
5697    pub const fn all() -> Self {
5698        Self(15u32)
5699    }
5700    ///Bit 0.
5701    pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(1u32);
5702    ///Bit 1.
5703    pub const ENABLE_RESOURCE_TRACKING: Self = Self(2u32);
5704    ///Bit 2.
5705    pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(4u32);
5706    ///Bit 3.
5707    pub const ENABLE_SHADER_ERROR_REPORTING: Self = Self(8u32);
5708}
5709impl core::ops::BitOr for DeviceDiagnosticsConfigFlagBitsNV {
5710    type Output = Self;
5711    #[inline]
5712    fn bitor(self, rhs: Self) -> Self {
5713        Self(self.0 | rhs.0)
5714    }
5715}
5716impl core::ops::BitOrAssign for DeviceDiagnosticsConfigFlagBitsNV {
5717    #[inline]
5718    fn bitor_assign(&mut self, rhs: Self) {
5719        self.0 |= rhs.0;
5720    }
5721}
5722impl core::ops::BitAnd for DeviceDiagnosticsConfigFlagBitsNV {
5723    type Output = Self;
5724    #[inline]
5725    fn bitand(self, rhs: Self) -> Self {
5726        Self(self.0 & rhs.0)
5727    }
5728}
5729impl core::ops::BitAndAssign for DeviceDiagnosticsConfigFlagBitsNV {
5730    #[inline]
5731    fn bitand_assign(&mut self, rhs: Self) {
5732        self.0 &= rhs.0;
5733    }
5734}
5735impl core::ops::BitXor for DeviceDiagnosticsConfigFlagBitsNV {
5736    type Output = Self;
5737    #[inline]
5738    fn bitxor(self, rhs: Self) -> Self {
5739        Self(self.0 ^ rhs.0)
5740    }
5741}
5742impl core::ops::BitXorAssign for DeviceDiagnosticsConfigFlagBitsNV {
5743    #[inline]
5744    fn bitxor_assign(&mut self, rhs: Self) {
5745        self.0 ^= rhs.0;
5746    }
5747}
5748impl core::ops::Not for DeviceDiagnosticsConfigFlagBitsNV {
5749    type Output = Self;
5750    #[inline]
5751    fn not(self) -> Self {
5752        Self(!self.0)
5753    }
5754}
5755impl core::fmt::Debug for DeviceDiagnosticsConfigFlagBitsNV {
5756    #[allow(unused_mut, unused_variables)]
5757    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5758        let mut first = true;
5759        let mut remaining = self.0;
5760        if remaining & Self::ENABLE_SHADER_DEBUG_INFO.0 != 0 {
5761            if !first {
5762                f.write_str(" | ")?;
5763            }
5764            f.write_str("ENABLE_SHADER_DEBUG_INFO")?;
5765            remaining &= !Self::ENABLE_SHADER_DEBUG_INFO.0;
5766            first = false;
5767        }
5768        if remaining & Self::ENABLE_RESOURCE_TRACKING.0 != 0 {
5769            if !first {
5770                f.write_str(" | ")?;
5771            }
5772            f.write_str("ENABLE_RESOURCE_TRACKING")?;
5773            remaining &= !Self::ENABLE_RESOURCE_TRACKING.0;
5774            first = false;
5775        }
5776        if remaining & Self::ENABLE_AUTOMATIC_CHECKPOINTS.0 != 0 {
5777            if !first {
5778                f.write_str(" | ")?;
5779            }
5780            f.write_str("ENABLE_AUTOMATIC_CHECKPOINTS")?;
5781            remaining &= !Self::ENABLE_AUTOMATIC_CHECKPOINTS.0;
5782            first = false;
5783        }
5784        if remaining & Self::ENABLE_SHADER_ERROR_REPORTING.0 != 0 {
5785            if !first {
5786                f.write_str(" | ")?;
5787            }
5788            f.write_str("ENABLE_SHADER_ERROR_REPORTING")?;
5789            remaining &= !Self::ENABLE_SHADER_ERROR_REPORTING.0;
5790            first = false;
5791        }
5792        if remaining != 0u32 {
5793            if !first {
5794                f.write_str(" | ")?;
5795            }
5796            write!(f, "{:#x}", remaining)?;
5797        } else if first {
5798            f.write_str("(empty)")?;
5799        }
5800        Ok(())
5801    }
5802}
5803///[`VkDeviceFaultFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultFlagBitsKHR.html)
5804#[repr(transparent)]
5805#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5806#[doc(alias = "VkDeviceFaultFlagBitsKHR")]
5807pub struct DeviceFaultFlagBitsKHR(u32);
5808impl DeviceFaultFlagBitsKHR {
5809    #[inline]
5810    pub const fn empty() -> Self {
5811        Self(0u32)
5812    }
5813    #[inline]
5814    pub const fn from_raw(value: u32) -> Self {
5815        Self(value)
5816    }
5817    #[inline]
5818    pub const fn as_raw(self) -> u32 {
5819        self.0
5820    }
5821    #[inline]
5822    pub const fn is_empty(self) -> bool {
5823        self.0 == 0u32
5824    }
5825    #[inline]
5826    pub const fn contains(self, other: Self) -> bool {
5827        (self.0 & other.0) == other.0
5828    }
5829    #[inline]
5830    pub const fn all() -> Self {
5831        Self(63u32)
5832    }
5833    ///Bit 0.
5834    pub const FLAG_DEVICE_LOST: Self = Self(1u32);
5835    ///Bit 1.
5836    pub const FLAG_MEMORY_ADDRESS: Self = Self(2u32);
5837    ///Bit 2.
5838    pub const FLAG_INSTRUCTION_ADDRESS: Self = Self(4u32);
5839    ///Bit 3.
5840    pub const FLAG_VENDOR: Self = Self(8u32);
5841    ///Bit 4.
5842    pub const FLAG_WATCHDOG_TIMEOUT: Self = Self(16u32);
5843    ///Bit 5.
5844    pub const FLAG_OVERFLOW: Self = Self(32u32);
5845}
5846impl core::ops::BitOr for DeviceFaultFlagBitsKHR {
5847    type Output = Self;
5848    #[inline]
5849    fn bitor(self, rhs: Self) -> Self {
5850        Self(self.0 | rhs.0)
5851    }
5852}
5853impl core::ops::BitOrAssign for DeviceFaultFlagBitsKHR {
5854    #[inline]
5855    fn bitor_assign(&mut self, rhs: Self) {
5856        self.0 |= rhs.0;
5857    }
5858}
5859impl core::ops::BitAnd for DeviceFaultFlagBitsKHR {
5860    type Output = Self;
5861    #[inline]
5862    fn bitand(self, rhs: Self) -> Self {
5863        Self(self.0 & rhs.0)
5864    }
5865}
5866impl core::ops::BitAndAssign for DeviceFaultFlagBitsKHR {
5867    #[inline]
5868    fn bitand_assign(&mut self, rhs: Self) {
5869        self.0 &= rhs.0;
5870    }
5871}
5872impl core::ops::BitXor for DeviceFaultFlagBitsKHR {
5873    type Output = Self;
5874    #[inline]
5875    fn bitxor(self, rhs: Self) -> Self {
5876        Self(self.0 ^ rhs.0)
5877    }
5878}
5879impl core::ops::BitXorAssign for DeviceFaultFlagBitsKHR {
5880    #[inline]
5881    fn bitxor_assign(&mut self, rhs: Self) {
5882        self.0 ^= rhs.0;
5883    }
5884}
5885impl core::ops::Not for DeviceFaultFlagBitsKHR {
5886    type Output = Self;
5887    #[inline]
5888    fn not(self) -> Self {
5889        Self(!self.0)
5890    }
5891}
5892impl core::fmt::Debug for DeviceFaultFlagBitsKHR {
5893    #[allow(unused_mut, unused_variables)]
5894    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5895        let mut first = true;
5896        let mut remaining = self.0;
5897        if remaining & Self::FLAG_DEVICE_LOST.0 != 0 {
5898            if !first {
5899                f.write_str(" | ")?;
5900            }
5901            f.write_str("FLAG_DEVICE_LOST")?;
5902            remaining &= !Self::FLAG_DEVICE_LOST.0;
5903            first = false;
5904        }
5905        if remaining & Self::FLAG_MEMORY_ADDRESS.0 != 0 {
5906            if !first {
5907                f.write_str(" | ")?;
5908            }
5909            f.write_str("FLAG_MEMORY_ADDRESS")?;
5910            remaining &= !Self::FLAG_MEMORY_ADDRESS.0;
5911            first = false;
5912        }
5913        if remaining & Self::FLAG_INSTRUCTION_ADDRESS.0 != 0 {
5914            if !first {
5915                f.write_str(" | ")?;
5916            }
5917            f.write_str("FLAG_INSTRUCTION_ADDRESS")?;
5918            remaining &= !Self::FLAG_INSTRUCTION_ADDRESS.0;
5919            first = false;
5920        }
5921        if remaining & Self::FLAG_VENDOR.0 != 0 {
5922            if !first {
5923                f.write_str(" | ")?;
5924            }
5925            f.write_str("FLAG_VENDOR")?;
5926            remaining &= !Self::FLAG_VENDOR.0;
5927            first = false;
5928        }
5929        if remaining & Self::FLAG_WATCHDOG_TIMEOUT.0 != 0 {
5930            if !first {
5931                f.write_str(" | ")?;
5932            }
5933            f.write_str("FLAG_WATCHDOG_TIMEOUT")?;
5934            remaining &= !Self::FLAG_WATCHDOG_TIMEOUT.0;
5935            first = false;
5936        }
5937        if remaining & Self::FLAG_OVERFLOW.0 != 0 {
5938            if !first {
5939                f.write_str(" | ")?;
5940            }
5941            f.write_str("FLAG_OVERFLOW")?;
5942            remaining &= !Self::FLAG_OVERFLOW.0;
5943            first = false;
5944        }
5945        if remaining != 0u32 {
5946            if !first {
5947                f.write_str(" | ")?;
5948            }
5949            write!(f, "{:#x}", remaining)?;
5950        } else if first {
5951            f.write_str("(empty)")?;
5952        }
5953        Ok(())
5954    }
5955}
5956///[`VkDeviceGroupPresentModeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html)
5957#[repr(transparent)]
5958#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5959#[doc(alias = "VkDeviceGroupPresentModeFlagBitsKHR")]
5960pub struct DeviceGroupPresentModeFlagBitsKHR(u32);
5961impl DeviceGroupPresentModeFlagBitsKHR {
5962    #[inline]
5963    pub const fn empty() -> Self {
5964        Self(0u32)
5965    }
5966    #[inline]
5967    pub const fn from_raw(value: u32) -> Self {
5968        Self(value)
5969    }
5970    #[inline]
5971    pub const fn as_raw(self) -> u32 {
5972        self.0
5973    }
5974    #[inline]
5975    pub const fn is_empty(self) -> bool {
5976        self.0 == 0u32
5977    }
5978    #[inline]
5979    pub const fn contains(self, other: Self) -> bool {
5980        (self.0 & other.0) == other.0
5981    }
5982    #[inline]
5983    pub const fn all() -> Self {
5984        Self(15u32)
5985    }
5986    ///Bit 0.
5987    pub const LOCAL: Self = Self(1u32);
5988    ///Bit 1.
5989    pub const REMOTE: Self = Self(2u32);
5990    ///Bit 2.
5991    pub const SUM: Self = Self(4u32);
5992    ///Bit 3.
5993    pub const LOCAL_MULTI_DEVICE: Self = Self(8u32);
5994}
5995impl core::ops::BitOr for DeviceGroupPresentModeFlagBitsKHR {
5996    type Output = Self;
5997    #[inline]
5998    fn bitor(self, rhs: Self) -> Self {
5999        Self(self.0 | rhs.0)
6000    }
6001}
6002impl core::ops::BitOrAssign for DeviceGroupPresentModeFlagBitsKHR {
6003    #[inline]
6004    fn bitor_assign(&mut self, rhs: Self) {
6005        self.0 |= rhs.0;
6006    }
6007}
6008impl core::ops::BitAnd for DeviceGroupPresentModeFlagBitsKHR {
6009    type Output = Self;
6010    #[inline]
6011    fn bitand(self, rhs: Self) -> Self {
6012        Self(self.0 & rhs.0)
6013    }
6014}
6015impl core::ops::BitAndAssign for DeviceGroupPresentModeFlagBitsKHR {
6016    #[inline]
6017    fn bitand_assign(&mut self, rhs: Self) {
6018        self.0 &= rhs.0;
6019    }
6020}
6021impl core::ops::BitXor for DeviceGroupPresentModeFlagBitsKHR {
6022    type Output = Self;
6023    #[inline]
6024    fn bitxor(self, rhs: Self) -> Self {
6025        Self(self.0 ^ rhs.0)
6026    }
6027}
6028impl core::ops::BitXorAssign for DeviceGroupPresentModeFlagBitsKHR {
6029    #[inline]
6030    fn bitxor_assign(&mut self, rhs: Self) {
6031        self.0 ^= rhs.0;
6032    }
6033}
6034impl core::ops::Not for DeviceGroupPresentModeFlagBitsKHR {
6035    type Output = Self;
6036    #[inline]
6037    fn not(self) -> Self {
6038        Self(!self.0)
6039    }
6040}
6041impl core::fmt::Debug for DeviceGroupPresentModeFlagBitsKHR {
6042    #[allow(unused_mut, unused_variables)]
6043    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6044        let mut first = true;
6045        let mut remaining = self.0;
6046        if remaining & Self::LOCAL.0 != 0 {
6047            if !first {
6048                f.write_str(" | ")?;
6049            }
6050            f.write_str("LOCAL")?;
6051            remaining &= !Self::LOCAL.0;
6052            first = false;
6053        }
6054        if remaining & Self::REMOTE.0 != 0 {
6055            if !first {
6056                f.write_str(" | ")?;
6057            }
6058            f.write_str("REMOTE")?;
6059            remaining &= !Self::REMOTE.0;
6060            first = false;
6061        }
6062        if remaining & Self::SUM.0 != 0 {
6063            if !first {
6064                f.write_str(" | ")?;
6065            }
6066            f.write_str("SUM")?;
6067            remaining &= !Self::SUM.0;
6068            first = false;
6069        }
6070        if remaining & Self::LOCAL_MULTI_DEVICE.0 != 0 {
6071            if !first {
6072                f.write_str(" | ")?;
6073            }
6074            f.write_str("LOCAL_MULTI_DEVICE")?;
6075            remaining &= !Self::LOCAL_MULTI_DEVICE.0;
6076            first = false;
6077        }
6078        if remaining != 0u32 {
6079            if !first {
6080                f.write_str(" | ")?;
6081            }
6082            write!(f, "{:#x}", remaining)?;
6083        } else if first {
6084            f.write_str("(empty)")?;
6085        }
6086        Ok(())
6087    }
6088}
6089///[`VkDeviceQueueCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateFlagBits.html)
6090#[repr(transparent)]
6091#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6092#[doc(alias = "VkDeviceQueueCreateFlagBits")]
6093pub struct DeviceQueueCreateFlagBits(u32);
6094impl DeviceQueueCreateFlagBits {
6095    #[inline]
6096    pub const fn empty() -> Self {
6097        Self(0u32)
6098    }
6099    #[inline]
6100    pub const fn from_raw(value: u32) -> Self {
6101        Self(value)
6102    }
6103    #[inline]
6104    pub const fn as_raw(self) -> u32 {
6105        self.0
6106    }
6107    #[inline]
6108    pub const fn is_empty(self) -> bool {
6109        self.0 == 0u32
6110    }
6111    #[inline]
6112    pub const fn contains(self, other: Self) -> bool {
6113        (self.0 & other.0) == other.0
6114    }
6115    #[inline]
6116    pub const fn all() -> Self {
6117        Self(5u32)
6118    }
6119    ///Bit 0.
6120    pub const PROTECTED: Self = Self(1u32);
6121    ///Bit 2.
6122    pub const INTERNALLY_SYNCHRONIZED: Self = Self(4u32);
6123}
6124impl core::ops::BitOr for DeviceQueueCreateFlagBits {
6125    type Output = Self;
6126    #[inline]
6127    fn bitor(self, rhs: Self) -> Self {
6128        Self(self.0 | rhs.0)
6129    }
6130}
6131impl core::ops::BitOrAssign for DeviceQueueCreateFlagBits {
6132    #[inline]
6133    fn bitor_assign(&mut self, rhs: Self) {
6134        self.0 |= rhs.0;
6135    }
6136}
6137impl core::ops::BitAnd for DeviceQueueCreateFlagBits {
6138    type Output = Self;
6139    #[inline]
6140    fn bitand(self, rhs: Self) -> Self {
6141        Self(self.0 & rhs.0)
6142    }
6143}
6144impl core::ops::BitAndAssign for DeviceQueueCreateFlagBits {
6145    #[inline]
6146    fn bitand_assign(&mut self, rhs: Self) {
6147        self.0 &= rhs.0;
6148    }
6149}
6150impl core::ops::BitXor for DeviceQueueCreateFlagBits {
6151    type Output = Self;
6152    #[inline]
6153    fn bitxor(self, rhs: Self) -> Self {
6154        Self(self.0 ^ rhs.0)
6155    }
6156}
6157impl core::ops::BitXorAssign for DeviceQueueCreateFlagBits {
6158    #[inline]
6159    fn bitxor_assign(&mut self, rhs: Self) {
6160        self.0 ^= rhs.0;
6161    }
6162}
6163impl core::ops::Not for DeviceQueueCreateFlagBits {
6164    type Output = Self;
6165    #[inline]
6166    fn not(self) -> Self {
6167        Self(!self.0)
6168    }
6169}
6170impl core::fmt::Debug for DeviceQueueCreateFlagBits {
6171    #[allow(unused_mut, unused_variables)]
6172    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6173        let mut first = true;
6174        let mut remaining = self.0;
6175        if remaining & Self::PROTECTED.0 != 0 {
6176            if !first {
6177                f.write_str(" | ")?;
6178            }
6179            f.write_str("PROTECTED")?;
6180            remaining &= !Self::PROTECTED.0;
6181            first = false;
6182        }
6183        if remaining & Self::INTERNALLY_SYNCHRONIZED.0 != 0 {
6184            if !first {
6185                f.write_str(" | ")?;
6186            }
6187            f.write_str("INTERNALLY_SYNCHRONIZED")?;
6188            remaining &= !Self::INTERNALLY_SYNCHRONIZED.0;
6189            first = false;
6190        }
6191        if remaining != 0u32 {
6192            if !first {
6193                f.write_str(" | ")?;
6194            }
6195            write!(f, "{:#x}", remaining)?;
6196        } else if first {
6197            f.write_str("(empty)")?;
6198        }
6199        Ok(())
6200    }
6201}
6202///[`VkDisplayPlaneAlphaFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html)
6203#[repr(transparent)]
6204#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6205#[doc(alias = "VkDisplayPlaneAlphaFlagBitsKHR")]
6206pub struct DisplayPlaneAlphaFlagBitsKHR(u32);
6207impl DisplayPlaneAlphaFlagBitsKHR {
6208    #[inline]
6209    pub const fn empty() -> Self {
6210        Self(0u32)
6211    }
6212    #[inline]
6213    pub const fn from_raw(value: u32) -> Self {
6214        Self(value)
6215    }
6216    #[inline]
6217    pub const fn as_raw(self) -> u32 {
6218        self.0
6219    }
6220    #[inline]
6221    pub const fn is_empty(self) -> bool {
6222        self.0 == 0u32
6223    }
6224    #[inline]
6225    pub const fn contains(self, other: Self) -> bool {
6226        (self.0 & other.0) == other.0
6227    }
6228    #[inline]
6229    pub const fn all() -> Self {
6230        Self(15u32)
6231    }
6232    ///Bit 0.
6233    pub const OPAQUE: Self = Self(1u32);
6234    ///Bit 1.
6235    pub const GLOBAL: Self = Self(2u32);
6236    ///Bit 2.
6237    pub const PER_PIXEL: Self = Self(4u32);
6238    ///Bit 3.
6239    pub const PER_PIXEL_PREMULTIPLIED: Self = Self(8u32);
6240}
6241impl core::ops::BitOr for DisplayPlaneAlphaFlagBitsKHR {
6242    type Output = Self;
6243    #[inline]
6244    fn bitor(self, rhs: Self) -> Self {
6245        Self(self.0 | rhs.0)
6246    }
6247}
6248impl core::ops::BitOrAssign for DisplayPlaneAlphaFlagBitsKHR {
6249    #[inline]
6250    fn bitor_assign(&mut self, rhs: Self) {
6251        self.0 |= rhs.0;
6252    }
6253}
6254impl core::ops::BitAnd for DisplayPlaneAlphaFlagBitsKHR {
6255    type Output = Self;
6256    #[inline]
6257    fn bitand(self, rhs: Self) -> Self {
6258        Self(self.0 & rhs.0)
6259    }
6260}
6261impl core::ops::BitAndAssign for DisplayPlaneAlphaFlagBitsKHR {
6262    #[inline]
6263    fn bitand_assign(&mut self, rhs: Self) {
6264        self.0 &= rhs.0;
6265    }
6266}
6267impl core::ops::BitXor for DisplayPlaneAlphaFlagBitsKHR {
6268    type Output = Self;
6269    #[inline]
6270    fn bitxor(self, rhs: Self) -> Self {
6271        Self(self.0 ^ rhs.0)
6272    }
6273}
6274impl core::ops::BitXorAssign for DisplayPlaneAlphaFlagBitsKHR {
6275    #[inline]
6276    fn bitxor_assign(&mut self, rhs: Self) {
6277        self.0 ^= rhs.0;
6278    }
6279}
6280impl core::ops::Not for DisplayPlaneAlphaFlagBitsKHR {
6281    type Output = Self;
6282    #[inline]
6283    fn not(self) -> Self {
6284        Self(!self.0)
6285    }
6286}
6287impl core::fmt::Debug for DisplayPlaneAlphaFlagBitsKHR {
6288    #[allow(unused_mut, unused_variables)]
6289    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6290        let mut first = true;
6291        let mut remaining = self.0;
6292        if remaining & Self::OPAQUE.0 != 0 {
6293            if !first {
6294                f.write_str(" | ")?;
6295            }
6296            f.write_str("OPAQUE")?;
6297            remaining &= !Self::OPAQUE.0;
6298            first = false;
6299        }
6300        if remaining & Self::GLOBAL.0 != 0 {
6301            if !first {
6302                f.write_str(" | ")?;
6303            }
6304            f.write_str("GLOBAL")?;
6305            remaining &= !Self::GLOBAL.0;
6306            first = false;
6307        }
6308        if remaining & Self::PER_PIXEL.0 != 0 {
6309            if !first {
6310                f.write_str(" | ")?;
6311            }
6312            f.write_str("PER_PIXEL")?;
6313            remaining &= !Self::PER_PIXEL.0;
6314            first = false;
6315        }
6316        if remaining & Self::PER_PIXEL_PREMULTIPLIED.0 != 0 {
6317            if !first {
6318                f.write_str(" | ")?;
6319            }
6320            f.write_str("PER_PIXEL_PREMULTIPLIED")?;
6321            remaining &= !Self::PER_PIXEL_PREMULTIPLIED.0;
6322            first = false;
6323        }
6324        if remaining != 0u32 {
6325            if !first {
6326                f.write_str(" | ")?;
6327            }
6328            write!(f, "{:#x}", remaining)?;
6329        } else if first {
6330            f.write_str("(empty)")?;
6331        }
6332        Ok(())
6333    }
6334}
6335///[`VkEventCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlagBits.html)
6336#[repr(transparent)]
6337#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6338#[doc(alias = "VkEventCreateFlagBits")]
6339pub struct EventCreateFlagBits(u32);
6340impl EventCreateFlagBits {
6341    #[inline]
6342    pub const fn empty() -> Self {
6343        Self(0u32)
6344    }
6345    #[inline]
6346    pub const fn from_raw(value: u32) -> Self {
6347        Self(value)
6348    }
6349    #[inline]
6350    pub const fn as_raw(self) -> u32 {
6351        self.0
6352    }
6353    #[inline]
6354    pub const fn is_empty(self) -> bool {
6355        self.0 == 0u32
6356    }
6357    #[inline]
6358    pub const fn contains(self, other: Self) -> bool {
6359        (self.0 & other.0) == other.0
6360    }
6361    #[inline]
6362    pub const fn all() -> Self {
6363        Self(1u32)
6364    }
6365    ///Bit 0.
6366    pub const DEVICE_ONLY: Self = Self(1u32);
6367}
6368impl core::ops::BitOr for EventCreateFlagBits {
6369    type Output = Self;
6370    #[inline]
6371    fn bitor(self, rhs: Self) -> Self {
6372        Self(self.0 | rhs.0)
6373    }
6374}
6375impl core::ops::BitOrAssign for EventCreateFlagBits {
6376    #[inline]
6377    fn bitor_assign(&mut self, rhs: Self) {
6378        self.0 |= rhs.0;
6379    }
6380}
6381impl core::ops::BitAnd for EventCreateFlagBits {
6382    type Output = Self;
6383    #[inline]
6384    fn bitand(self, rhs: Self) -> Self {
6385        Self(self.0 & rhs.0)
6386    }
6387}
6388impl core::ops::BitAndAssign for EventCreateFlagBits {
6389    #[inline]
6390    fn bitand_assign(&mut self, rhs: Self) {
6391        self.0 &= rhs.0;
6392    }
6393}
6394impl core::ops::BitXor for EventCreateFlagBits {
6395    type Output = Self;
6396    #[inline]
6397    fn bitxor(self, rhs: Self) -> Self {
6398        Self(self.0 ^ rhs.0)
6399    }
6400}
6401impl core::ops::BitXorAssign for EventCreateFlagBits {
6402    #[inline]
6403    fn bitxor_assign(&mut self, rhs: Self) {
6404        self.0 ^= rhs.0;
6405    }
6406}
6407impl core::ops::Not for EventCreateFlagBits {
6408    type Output = Self;
6409    #[inline]
6410    fn not(self) -> Self {
6411        Self(!self.0)
6412    }
6413}
6414impl core::fmt::Debug for EventCreateFlagBits {
6415    #[allow(unused_mut, unused_variables)]
6416    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6417        let mut first = true;
6418        let mut remaining = self.0;
6419        if remaining & Self::DEVICE_ONLY.0 != 0 {
6420            if !first {
6421                f.write_str(" | ")?;
6422            }
6423            f.write_str("DEVICE_ONLY")?;
6424            remaining &= !Self::DEVICE_ONLY.0;
6425            first = false;
6426        }
6427        if remaining != 0u32 {
6428            if !first {
6429                f.write_str(" | ")?;
6430            }
6431            write!(f, "{:#x}", remaining)?;
6432        } else if first {
6433            f.write_str("(empty)")?;
6434        }
6435        Ok(())
6436    }
6437}
6438///[`VkExportMetalObjectTypeFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectTypeFlagBitsEXT.html)
6439#[repr(transparent)]
6440#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6441#[doc(alias = "VkExportMetalObjectTypeFlagBitsEXT")]
6442pub struct ExportMetalObjectTypeFlagBitsEXT(u32);
6443impl ExportMetalObjectTypeFlagBitsEXT {
6444    #[inline]
6445    pub const fn empty() -> Self {
6446        Self(0u32)
6447    }
6448    #[inline]
6449    pub const fn from_raw(value: u32) -> Self {
6450        Self(value)
6451    }
6452    #[inline]
6453    pub const fn as_raw(self) -> u32 {
6454        self.0
6455    }
6456    #[inline]
6457    pub const fn is_empty(self) -> bool {
6458        self.0 == 0u32
6459    }
6460    #[inline]
6461    pub const fn contains(self, other: Self) -> bool {
6462        (self.0 & other.0) == other.0
6463    }
6464    #[inline]
6465    pub const fn all() -> Self {
6466        Self(63u32)
6467    }
6468    ///Bit 0.
6469    pub const METAL_DEVICE: Self = Self(1u32);
6470    ///Bit 1.
6471    pub const METAL_COMMAND_QUEUE: Self = Self(2u32);
6472    ///Bit 2.
6473    pub const METAL_BUFFER: Self = Self(4u32);
6474    ///Bit 3.
6475    pub const METAL_TEXTURE: Self = Self(8u32);
6476    ///Bit 4.
6477    pub const METAL_IOSURFACE: Self = Self(16u32);
6478    ///Bit 5.
6479    pub const METAL_SHARED_EVENT: Self = Self(32u32);
6480}
6481impl core::ops::BitOr for ExportMetalObjectTypeFlagBitsEXT {
6482    type Output = Self;
6483    #[inline]
6484    fn bitor(self, rhs: Self) -> Self {
6485        Self(self.0 | rhs.0)
6486    }
6487}
6488impl core::ops::BitOrAssign for ExportMetalObjectTypeFlagBitsEXT {
6489    #[inline]
6490    fn bitor_assign(&mut self, rhs: Self) {
6491        self.0 |= rhs.0;
6492    }
6493}
6494impl core::ops::BitAnd for ExportMetalObjectTypeFlagBitsEXT {
6495    type Output = Self;
6496    #[inline]
6497    fn bitand(self, rhs: Self) -> Self {
6498        Self(self.0 & rhs.0)
6499    }
6500}
6501impl core::ops::BitAndAssign for ExportMetalObjectTypeFlagBitsEXT {
6502    #[inline]
6503    fn bitand_assign(&mut self, rhs: Self) {
6504        self.0 &= rhs.0;
6505    }
6506}
6507impl core::ops::BitXor for ExportMetalObjectTypeFlagBitsEXT {
6508    type Output = Self;
6509    #[inline]
6510    fn bitxor(self, rhs: Self) -> Self {
6511        Self(self.0 ^ rhs.0)
6512    }
6513}
6514impl core::ops::BitXorAssign for ExportMetalObjectTypeFlagBitsEXT {
6515    #[inline]
6516    fn bitxor_assign(&mut self, rhs: Self) {
6517        self.0 ^= rhs.0;
6518    }
6519}
6520impl core::ops::Not for ExportMetalObjectTypeFlagBitsEXT {
6521    type Output = Self;
6522    #[inline]
6523    fn not(self) -> Self {
6524        Self(!self.0)
6525    }
6526}
6527impl core::fmt::Debug for ExportMetalObjectTypeFlagBitsEXT {
6528    #[allow(unused_mut, unused_variables)]
6529    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6530        let mut first = true;
6531        let mut remaining = self.0;
6532        if remaining & Self::METAL_DEVICE.0 != 0 {
6533            if !first {
6534                f.write_str(" | ")?;
6535            }
6536            f.write_str("METAL_DEVICE")?;
6537            remaining &= !Self::METAL_DEVICE.0;
6538            first = false;
6539        }
6540        if remaining & Self::METAL_COMMAND_QUEUE.0 != 0 {
6541            if !first {
6542                f.write_str(" | ")?;
6543            }
6544            f.write_str("METAL_COMMAND_QUEUE")?;
6545            remaining &= !Self::METAL_COMMAND_QUEUE.0;
6546            first = false;
6547        }
6548        if remaining & Self::METAL_BUFFER.0 != 0 {
6549            if !first {
6550                f.write_str(" | ")?;
6551            }
6552            f.write_str("METAL_BUFFER")?;
6553            remaining &= !Self::METAL_BUFFER.0;
6554            first = false;
6555        }
6556        if remaining & Self::METAL_TEXTURE.0 != 0 {
6557            if !first {
6558                f.write_str(" | ")?;
6559            }
6560            f.write_str("METAL_TEXTURE")?;
6561            remaining &= !Self::METAL_TEXTURE.0;
6562            first = false;
6563        }
6564        if remaining & Self::METAL_IOSURFACE.0 != 0 {
6565            if !first {
6566                f.write_str(" | ")?;
6567            }
6568            f.write_str("METAL_IOSURFACE")?;
6569            remaining &= !Self::METAL_IOSURFACE.0;
6570            first = false;
6571        }
6572        if remaining & Self::METAL_SHARED_EVENT.0 != 0 {
6573            if !first {
6574                f.write_str(" | ")?;
6575            }
6576            f.write_str("METAL_SHARED_EVENT")?;
6577            remaining &= !Self::METAL_SHARED_EVENT.0;
6578            first = false;
6579        }
6580        if remaining != 0u32 {
6581            if !first {
6582                f.write_str(" | ")?;
6583            }
6584            write!(f, "{:#x}", remaining)?;
6585        } else if first {
6586            f.write_str("(empty)")?;
6587        }
6588        Ok(())
6589    }
6590}
6591///[`VkExternalFenceFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceFeatureFlagBits.html)
6592#[repr(transparent)]
6593#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6594#[doc(alias = "VkExternalFenceFeatureFlagBits")]
6595pub struct ExternalFenceFeatureFlagBits(u32);
6596impl ExternalFenceFeatureFlagBits {
6597    #[inline]
6598    pub const fn empty() -> Self {
6599        Self(0u32)
6600    }
6601    #[inline]
6602    pub const fn from_raw(value: u32) -> Self {
6603        Self(value)
6604    }
6605    #[inline]
6606    pub const fn as_raw(self) -> u32 {
6607        self.0
6608    }
6609    #[inline]
6610    pub const fn is_empty(self) -> bool {
6611        self.0 == 0u32
6612    }
6613    #[inline]
6614    pub const fn contains(self, other: Self) -> bool {
6615        (self.0 & other.0) == other.0
6616    }
6617    #[inline]
6618    pub const fn all() -> Self {
6619        Self(3u32)
6620    }
6621    ///Bit 0.
6622    pub const EXPORTABLE: Self = Self(1u32);
6623    ///Bit 1.
6624    pub const IMPORTABLE: Self = Self(2u32);
6625}
6626impl core::ops::BitOr for ExternalFenceFeatureFlagBits {
6627    type Output = Self;
6628    #[inline]
6629    fn bitor(self, rhs: Self) -> Self {
6630        Self(self.0 | rhs.0)
6631    }
6632}
6633impl core::ops::BitOrAssign for ExternalFenceFeatureFlagBits {
6634    #[inline]
6635    fn bitor_assign(&mut self, rhs: Self) {
6636        self.0 |= rhs.0;
6637    }
6638}
6639impl core::ops::BitAnd for ExternalFenceFeatureFlagBits {
6640    type Output = Self;
6641    #[inline]
6642    fn bitand(self, rhs: Self) -> Self {
6643        Self(self.0 & rhs.0)
6644    }
6645}
6646impl core::ops::BitAndAssign for ExternalFenceFeatureFlagBits {
6647    #[inline]
6648    fn bitand_assign(&mut self, rhs: Self) {
6649        self.0 &= rhs.0;
6650    }
6651}
6652impl core::ops::BitXor for ExternalFenceFeatureFlagBits {
6653    type Output = Self;
6654    #[inline]
6655    fn bitxor(self, rhs: Self) -> Self {
6656        Self(self.0 ^ rhs.0)
6657    }
6658}
6659impl core::ops::BitXorAssign for ExternalFenceFeatureFlagBits {
6660    #[inline]
6661    fn bitxor_assign(&mut self, rhs: Self) {
6662        self.0 ^= rhs.0;
6663    }
6664}
6665impl core::ops::Not for ExternalFenceFeatureFlagBits {
6666    type Output = Self;
6667    #[inline]
6668    fn not(self) -> Self {
6669        Self(!self.0)
6670    }
6671}
6672impl core::fmt::Debug for ExternalFenceFeatureFlagBits {
6673    #[allow(unused_mut, unused_variables)]
6674    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6675        let mut first = true;
6676        let mut remaining = self.0;
6677        if remaining & Self::EXPORTABLE.0 != 0 {
6678            if !first {
6679                f.write_str(" | ")?;
6680            }
6681            f.write_str("EXPORTABLE")?;
6682            remaining &= !Self::EXPORTABLE.0;
6683            first = false;
6684        }
6685        if remaining & Self::IMPORTABLE.0 != 0 {
6686            if !first {
6687                f.write_str(" | ")?;
6688            }
6689            f.write_str("IMPORTABLE")?;
6690            remaining &= !Self::IMPORTABLE.0;
6691            first = false;
6692        }
6693        if remaining != 0u32 {
6694            if !first {
6695                f.write_str(" | ")?;
6696            }
6697            write!(f, "{:#x}", remaining)?;
6698        } else if first {
6699            f.write_str("(empty)")?;
6700        }
6701        Ok(())
6702    }
6703}
6704///[`VkExternalFenceHandleTypeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceHandleTypeFlagBits.html)
6705#[repr(transparent)]
6706#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6707#[doc(alias = "VkExternalFenceHandleTypeFlagBits")]
6708pub struct ExternalFenceHandleTypeFlagBits(u32);
6709impl ExternalFenceHandleTypeFlagBits {
6710    #[inline]
6711    pub const fn empty() -> Self {
6712        Self(0u32)
6713    }
6714    #[inline]
6715    pub const fn from_raw(value: u32) -> Self {
6716        Self(value)
6717    }
6718    #[inline]
6719    pub const fn as_raw(self) -> u32 {
6720        self.0
6721    }
6722    #[inline]
6723    pub const fn is_empty(self) -> bool {
6724        self.0 == 0u32
6725    }
6726    #[inline]
6727    pub const fn contains(self, other: Self) -> bool {
6728        (self.0 & other.0) == other.0
6729    }
6730    #[inline]
6731    pub const fn all() -> Self {
6732        Self(15u32)
6733    }
6734    ///Bit 0.
6735    pub const OPAQUE_FD: Self = Self(1u32);
6736    ///Bit 1.
6737    pub const OPAQUE_WIN32: Self = Self(2u32);
6738    ///Bit 2.
6739    pub const OPAQUE_WIN32_KMT: Self = Self(4u32);
6740    ///Bit 3.
6741    pub const SYNC_FD: Self = Self(8u32);
6742}
6743impl core::ops::BitOr for ExternalFenceHandleTypeFlagBits {
6744    type Output = Self;
6745    #[inline]
6746    fn bitor(self, rhs: Self) -> Self {
6747        Self(self.0 | rhs.0)
6748    }
6749}
6750impl core::ops::BitOrAssign for ExternalFenceHandleTypeFlagBits {
6751    #[inline]
6752    fn bitor_assign(&mut self, rhs: Self) {
6753        self.0 |= rhs.0;
6754    }
6755}
6756impl core::ops::BitAnd for ExternalFenceHandleTypeFlagBits {
6757    type Output = Self;
6758    #[inline]
6759    fn bitand(self, rhs: Self) -> Self {
6760        Self(self.0 & rhs.0)
6761    }
6762}
6763impl core::ops::BitAndAssign for ExternalFenceHandleTypeFlagBits {
6764    #[inline]
6765    fn bitand_assign(&mut self, rhs: Self) {
6766        self.0 &= rhs.0;
6767    }
6768}
6769impl core::ops::BitXor for ExternalFenceHandleTypeFlagBits {
6770    type Output = Self;
6771    #[inline]
6772    fn bitxor(self, rhs: Self) -> Self {
6773        Self(self.0 ^ rhs.0)
6774    }
6775}
6776impl core::ops::BitXorAssign for ExternalFenceHandleTypeFlagBits {
6777    #[inline]
6778    fn bitxor_assign(&mut self, rhs: Self) {
6779        self.0 ^= rhs.0;
6780    }
6781}
6782impl core::ops::Not for ExternalFenceHandleTypeFlagBits {
6783    type Output = Self;
6784    #[inline]
6785    fn not(self) -> Self {
6786        Self(!self.0)
6787    }
6788}
6789impl core::fmt::Debug for ExternalFenceHandleTypeFlagBits {
6790    #[allow(unused_mut, unused_variables)]
6791    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6792        let mut first = true;
6793        let mut remaining = self.0;
6794        if remaining & Self::OPAQUE_FD.0 != 0 {
6795            if !first {
6796                f.write_str(" | ")?;
6797            }
6798            f.write_str("OPAQUE_FD")?;
6799            remaining &= !Self::OPAQUE_FD.0;
6800            first = false;
6801        }
6802        if remaining & Self::OPAQUE_WIN32.0 != 0 {
6803            if !first {
6804                f.write_str(" | ")?;
6805            }
6806            f.write_str("OPAQUE_WIN32")?;
6807            remaining &= !Self::OPAQUE_WIN32.0;
6808            first = false;
6809        }
6810        if remaining & Self::OPAQUE_WIN32_KMT.0 != 0 {
6811            if !first {
6812                f.write_str(" | ")?;
6813            }
6814            f.write_str("OPAQUE_WIN32_KMT")?;
6815            remaining &= !Self::OPAQUE_WIN32_KMT.0;
6816            first = false;
6817        }
6818        if remaining & Self::SYNC_FD.0 != 0 {
6819            if !first {
6820                f.write_str(" | ")?;
6821            }
6822            f.write_str("SYNC_FD")?;
6823            remaining &= !Self::SYNC_FD.0;
6824            first = false;
6825        }
6826        if remaining != 0u32 {
6827            if !first {
6828                f.write_str(" | ")?;
6829            }
6830            write!(f, "{:#x}", remaining)?;
6831        } else if first {
6832            f.write_str("(empty)")?;
6833        }
6834        Ok(())
6835    }
6836}
6837///[`VkExternalMemoryFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagBits.html)
6838#[repr(transparent)]
6839#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6840#[doc(alias = "VkExternalMemoryFeatureFlagBits")]
6841pub struct ExternalMemoryFeatureFlagBits(u32);
6842impl ExternalMemoryFeatureFlagBits {
6843    #[inline]
6844    pub const fn empty() -> Self {
6845        Self(0u32)
6846    }
6847    #[inline]
6848    pub const fn from_raw(value: u32) -> Self {
6849        Self(value)
6850    }
6851    #[inline]
6852    pub const fn as_raw(self) -> u32 {
6853        self.0
6854    }
6855    #[inline]
6856    pub const fn is_empty(self) -> bool {
6857        self.0 == 0u32
6858    }
6859    #[inline]
6860    pub const fn contains(self, other: Self) -> bool {
6861        (self.0 & other.0) == other.0
6862    }
6863    #[inline]
6864    pub const fn all() -> Self {
6865        Self(7u32)
6866    }
6867    ///Bit 0.
6868    pub const DEDICATED_ONLY: Self = Self(1u32);
6869    ///Bit 1.
6870    pub const EXPORTABLE: Self = Self(2u32);
6871    ///Bit 2.
6872    pub const IMPORTABLE: Self = Self(4u32);
6873}
6874impl core::ops::BitOr for ExternalMemoryFeatureFlagBits {
6875    type Output = Self;
6876    #[inline]
6877    fn bitor(self, rhs: Self) -> Self {
6878        Self(self.0 | rhs.0)
6879    }
6880}
6881impl core::ops::BitOrAssign for ExternalMemoryFeatureFlagBits {
6882    #[inline]
6883    fn bitor_assign(&mut self, rhs: Self) {
6884        self.0 |= rhs.0;
6885    }
6886}
6887impl core::ops::BitAnd for ExternalMemoryFeatureFlagBits {
6888    type Output = Self;
6889    #[inline]
6890    fn bitand(self, rhs: Self) -> Self {
6891        Self(self.0 & rhs.0)
6892    }
6893}
6894impl core::ops::BitAndAssign for ExternalMemoryFeatureFlagBits {
6895    #[inline]
6896    fn bitand_assign(&mut self, rhs: Self) {
6897        self.0 &= rhs.0;
6898    }
6899}
6900impl core::ops::BitXor for ExternalMemoryFeatureFlagBits {
6901    type Output = Self;
6902    #[inline]
6903    fn bitxor(self, rhs: Self) -> Self {
6904        Self(self.0 ^ rhs.0)
6905    }
6906}
6907impl core::ops::BitXorAssign for ExternalMemoryFeatureFlagBits {
6908    #[inline]
6909    fn bitxor_assign(&mut self, rhs: Self) {
6910        self.0 ^= rhs.0;
6911    }
6912}
6913impl core::ops::Not for ExternalMemoryFeatureFlagBits {
6914    type Output = Self;
6915    #[inline]
6916    fn not(self) -> Self {
6917        Self(!self.0)
6918    }
6919}
6920impl core::fmt::Debug for ExternalMemoryFeatureFlagBits {
6921    #[allow(unused_mut, unused_variables)]
6922    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6923        let mut first = true;
6924        let mut remaining = self.0;
6925        if remaining & Self::DEDICATED_ONLY.0 != 0 {
6926            if !first {
6927                f.write_str(" | ")?;
6928            }
6929            f.write_str("DEDICATED_ONLY")?;
6930            remaining &= !Self::DEDICATED_ONLY.0;
6931            first = false;
6932        }
6933        if remaining & Self::EXPORTABLE.0 != 0 {
6934            if !first {
6935                f.write_str(" | ")?;
6936            }
6937            f.write_str("EXPORTABLE")?;
6938            remaining &= !Self::EXPORTABLE.0;
6939            first = false;
6940        }
6941        if remaining & Self::IMPORTABLE.0 != 0 {
6942            if !first {
6943                f.write_str(" | ")?;
6944            }
6945            f.write_str("IMPORTABLE")?;
6946            remaining &= !Self::IMPORTABLE.0;
6947            first = false;
6948        }
6949        if remaining != 0u32 {
6950            if !first {
6951                f.write_str(" | ")?;
6952            }
6953            write!(f, "{:#x}", remaining)?;
6954        } else if first {
6955            f.write_str("(empty)")?;
6956        }
6957        Ok(())
6958    }
6959}
6960///[`VkExternalMemoryFeatureFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagBitsNV.html)
6961#[repr(transparent)]
6962#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6963#[doc(alias = "VkExternalMemoryFeatureFlagBitsNV")]
6964pub struct ExternalMemoryFeatureFlagBitsNV(u32);
6965impl ExternalMemoryFeatureFlagBitsNV {
6966    #[inline]
6967    pub const fn empty() -> Self {
6968        Self(0u32)
6969    }
6970    #[inline]
6971    pub const fn from_raw(value: u32) -> Self {
6972        Self(value)
6973    }
6974    #[inline]
6975    pub const fn as_raw(self) -> u32 {
6976        self.0
6977    }
6978    #[inline]
6979    pub const fn is_empty(self) -> bool {
6980        self.0 == 0u32
6981    }
6982    #[inline]
6983    pub const fn contains(self, other: Self) -> bool {
6984        (self.0 & other.0) == other.0
6985    }
6986    #[inline]
6987    pub const fn all() -> Self {
6988        Self(7u32)
6989    }
6990    ///Bit 0.
6991    pub const DEDICATED_ONLY: Self = Self(1u32);
6992    ///Bit 1.
6993    pub const EXPORTABLE: Self = Self(2u32);
6994    ///Bit 2.
6995    pub const IMPORTABLE: Self = Self(4u32);
6996}
6997impl core::ops::BitOr for ExternalMemoryFeatureFlagBitsNV {
6998    type Output = Self;
6999    #[inline]
7000    fn bitor(self, rhs: Self) -> Self {
7001        Self(self.0 | rhs.0)
7002    }
7003}
7004impl core::ops::BitOrAssign for ExternalMemoryFeatureFlagBitsNV {
7005    #[inline]
7006    fn bitor_assign(&mut self, rhs: Self) {
7007        self.0 |= rhs.0;
7008    }
7009}
7010impl core::ops::BitAnd for ExternalMemoryFeatureFlagBitsNV {
7011    type Output = Self;
7012    #[inline]
7013    fn bitand(self, rhs: Self) -> Self {
7014        Self(self.0 & rhs.0)
7015    }
7016}
7017impl core::ops::BitAndAssign for ExternalMemoryFeatureFlagBitsNV {
7018    #[inline]
7019    fn bitand_assign(&mut self, rhs: Self) {
7020        self.0 &= rhs.0;
7021    }
7022}
7023impl core::ops::BitXor for ExternalMemoryFeatureFlagBitsNV {
7024    type Output = Self;
7025    #[inline]
7026    fn bitxor(self, rhs: Self) -> Self {
7027        Self(self.0 ^ rhs.0)
7028    }
7029}
7030impl core::ops::BitXorAssign for ExternalMemoryFeatureFlagBitsNV {
7031    #[inline]
7032    fn bitxor_assign(&mut self, rhs: Self) {
7033        self.0 ^= rhs.0;
7034    }
7035}
7036impl core::ops::Not for ExternalMemoryFeatureFlagBitsNV {
7037    type Output = Self;
7038    #[inline]
7039    fn not(self) -> Self {
7040        Self(!self.0)
7041    }
7042}
7043impl core::fmt::Debug for ExternalMemoryFeatureFlagBitsNV {
7044    #[allow(unused_mut, unused_variables)]
7045    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7046        let mut first = true;
7047        let mut remaining = self.0;
7048        if remaining & Self::DEDICATED_ONLY.0 != 0 {
7049            if !first {
7050                f.write_str(" | ")?;
7051            }
7052            f.write_str("DEDICATED_ONLY")?;
7053            remaining &= !Self::DEDICATED_ONLY.0;
7054            first = false;
7055        }
7056        if remaining & Self::EXPORTABLE.0 != 0 {
7057            if !first {
7058                f.write_str(" | ")?;
7059            }
7060            f.write_str("EXPORTABLE")?;
7061            remaining &= !Self::EXPORTABLE.0;
7062            first = false;
7063        }
7064        if remaining & Self::IMPORTABLE.0 != 0 {
7065            if !first {
7066                f.write_str(" | ")?;
7067            }
7068            f.write_str("IMPORTABLE")?;
7069            remaining &= !Self::IMPORTABLE.0;
7070            first = false;
7071        }
7072        if remaining != 0u32 {
7073            if !first {
7074                f.write_str(" | ")?;
7075            }
7076            write!(f, "{:#x}", remaining)?;
7077        } else if first {
7078            f.write_str("(empty)")?;
7079        }
7080        Ok(())
7081    }
7082}
7083///[`VkExternalMemoryHandleTypeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagBits.html)
7084#[repr(transparent)]
7085#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
7086#[doc(alias = "VkExternalMemoryHandleTypeFlagBits")]
7087pub struct ExternalMemoryHandleTypeFlagBits(u32);
7088impl ExternalMemoryHandleTypeFlagBits {
7089    #[inline]
7090    pub const fn empty() -> Self {
7091        Self(0u32)
7092    }
7093    #[inline]
7094    pub const fn from_raw(value: u32) -> Self {
7095        Self(value)
7096    }
7097    #[inline]
7098    pub const fn as_raw(self) -> u32 {
7099        self.0
7100    }
7101    #[inline]
7102    pub const fn is_empty(self) -> bool {
7103        self.0 == 0u32
7104    }
7105    #[inline]
7106    pub const fn contains(self, other: Self) -> bool {
7107        (self.0 & other.0) == other.0
7108    }
7109    #[inline]
7110    pub const fn all() -> Self {
7111        Self(516095u32)
7112    }
7113    ///Bit 0.
7114    pub const OPAQUE_FD: Self = Self(1u32);
7115    ///Bit 1.
7116    pub const OPAQUE_WIN32: Self = Self(2u32);
7117    ///Bit 2.
7118    pub const OPAQUE_WIN32_KMT: Self = Self(4u32);
7119    ///Bit 3.
7120    pub const D3D11_TEXTURE: Self = Self(8u32);
7121    ///Bit 4.
7122    pub const D3D11_TEXTURE_KMT: Self = Self(16u32);
7123    ///Bit 5.
7124    pub const D3D12_HEAP: Self = Self(32u32);
7125    ///Bit 6.
7126    pub const D3D12_RESOURCE: Self = Self(64u32);
7127    ///Bit 9.
7128    pub const DMA_BUF: Self = Self(512u32);
7129    ///Bit 10.
7130    pub const ANDROID_HARDWARE_BUFFER_BIT: Self = Self(1024u32);
7131    ///Bit 7.
7132    pub const HOST_ALLOCATION: Self = Self(128u32);
7133    ///Bit 8.
7134    pub const HOST_MAPPED_FOREIGN_MEMORY: Self = Self(256u32);
7135    ///Bit 11.
7136    pub const ZIRCON_VMO_BIT: Self = Self(2048u32);
7137    ///Bit 12.
7138    pub const RDMA_ADDRESS: Self = Self(4096u32);
7139    ///Bit 15.
7140    pub const OH_NATIVE_BUFFER_BIT: Self = Self(32768u32);
7141    ///Bit 14.
7142    pub const SCREEN_BUFFER_BIT: Self = Self(16384u32);
7143    ///Bit 16.
7144    pub const MTLBUFFER: Self = Self(65536u32);
7145    ///Bit 17.
7146    pub const MTLTEXTURE: Self = Self(131072u32);
7147    ///Bit 18.
7148    pub const MTLHEAP: Self = Self(262144u32);
7149}
7150impl core::ops::BitOr for ExternalMemoryHandleTypeFlagBits {
7151    type Output = Self;
7152    #[inline]
7153    fn bitor(self, rhs: Self) -> Self {
7154        Self(self.0 | rhs.0)
7155    }
7156}
7157impl core::ops::BitOrAssign for ExternalMemoryHandleTypeFlagBits {
7158    #[inline]
7159    fn bitor_assign(&mut self, rhs: Self) {
7160        self.0 |= rhs.0;
7161    }
7162}
7163impl core::ops::BitAnd for ExternalMemoryHandleTypeFlagBits {
7164    type Output = Self;
7165    #[inline]
7166    fn bitand(self, rhs: Self) -> Self {
7167        Self(self.0 & rhs.0)
7168    }
7169}
7170impl core::ops::BitAndAssign for ExternalMemoryHandleTypeFlagBits {
7171    #[inline]
7172    fn bitand_assign(&mut self, rhs: Self) {
7173        self.0 &= rhs.0;
7174    }
7175}
7176impl core::ops::BitXor for ExternalMemoryHandleTypeFlagBits {
7177    type Output = Self;
7178    #[inline]
7179    fn bitxor(self, rhs: Self) -> Self {
7180        Self(self.0 ^ rhs.0)
7181    }
7182}
7183impl core::ops::BitXorAssign for ExternalMemoryHandleTypeFlagBits {
7184    #[inline]
7185    fn bitxor_assign(&mut self, rhs: Self) {
7186        self.0 ^= rhs.0;
7187    }
7188}
7189impl core::ops::Not for ExternalMemoryHandleTypeFlagBits {
7190    type Output = Self;
7191    #[inline]
7192    fn not(self) -> Self {
7193        Self(!self.0)
7194    }
7195}
7196impl core::fmt::Debug for ExternalMemoryHandleTypeFlagBits {
7197    #[allow(unused_mut, unused_variables)]
7198    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7199        let mut first = true;
7200        let mut remaining = self.0;
7201        if remaining & Self::OPAQUE_FD.0 != 0 {
7202            if !first {
7203                f.write_str(" | ")?;
7204            }
7205            f.write_str("OPAQUE_FD")?;
7206            remaining &= !Self::OPAQUE_FD.0;
7207            first = false;
7208        }
7209        if remaining & Self::OPAQUE_WIN32.0 != 0 {
7210            if !first {
7211                f.write_str(" | ")?;
7212            }
7213            f.write_str("OPAQUE_WIN32")?;
7214            remaining &= !Self::OPAQUE_WIN32.0;
7215            first = false;
7216        }
7217        if remaining & Self::OPAQUE_WIN32_KMT.0 != 0 {
7218            if !first {
7219                f.write_str(" | ")?;
7220            }
7221            f.write_str("OPAQUE_WIN32_KMT")?;
7222            remaining &= !Self::OPAQUE_WIN32_KMT.0;
7223            first = false;
7224        }
7225        if remaining & Self::D3D11_TEXTURE.0 != 0 {
7226            if !first {
7227                f.write_str(" | ")?;
7228            }
7229            f.write_str("D3D11_TEXTURE")?;
7230            remaining &= !Self::D3D11_TEXTURE.0;
7231            first = false;
7232        }
7233        if remaining & Self::D3D11_TEXTURE_KMT.0 != 0 {
7234            if !first {
7235                f.write_str(" | ")?;
7236            }
7237            f.write_str("D3D11_TEXTURE_KMT")?;
7238            remaining &= !Self::D3D11_TEXTURE_KMT.0;
7239            first = false;
7240        }
7241        if remaining & Self::D3D12_HEAP.0 != 0 {
7242            if !first {
7243                f.write_str(" | ")?;
7244            }
7245            f.write_str("D3D12_HEAP")?;
7246            remaining &= !Self::D3D12_HEAP.0;
7247            first = false;
7248        }
7249        if remaining & Self::D3D12_RESOURCE.0 != 0 {
7250            if !first {
7251                f.write_str(" | ")?;
7252            }
7253            f.write_str("D3D12_RESOURCE")?;
7254            remaining &= !Self::D3D12_RESOURCE.0;
7255            first = false;
7256        }
7257        if remaining & Self::DMA_BUF.0 != 0 {
7258            if !first {
7259                f.write_str(" | ")?;
7260            }
7261            f.write_str("DMA_BUF")?;
7262            remaining &= !Self::DMA_BUF.0;
7263            first = false;
7264        }
7265        if remaining & Self::ANDROID_HARDWARE_BUFFER_BIT.0 != 0 {
7266            if !first {
7267                f.write_str(" | ")?;
7268            }
7269            f.write_str("ANDROID_HARDWARE_BUFFER_BIT")?;
7270            remaining &= !Self::ANDROID_HARDWARE_BUFFER_BIT.0;
7271            first = false;
7272        }
7273        if remaining & Self::HOST_ALLOCATION.0 != 0 {
7274            if !first {
7275                f.write_str(" | ")?;
7276            }
7277            f.write_str("HOST_ALLOCATION")?;
7278            remaining &= !Self::HOST_ALLOCATION.0;
7279            first = false;
7280        }
7281        if remaining & Self::HOST_MAPPED_FOREIGN_MEMORY.0 != 0 {
7282            if !first {
7283                f.write_str(" | ")?;
7284            }
7285            f.write_str("HOST_MAPPED_FOREIGN_MEMORY")?;
7286            remaining &= !Self::HOST_MAPPED_FOREIGN_MEMORY.0;
7287            first = false;
7288        }
7289        if remaining & Self::ZIRCON_VMO_BIT.0 != 0 {
7290            if !first {
7291                f.write_str(" | ")?;
7292            }
7293            f.write_str("ZIRCON_VMO_BIT")?;
7294            remaining &= !Self::ZIRCON_VMO_BIT.0;
7295            first = false;
7296        }
7297        if remaining & Self::RDMA_ADDRESS.0 != 0 {
7298            if !first {
7299                f.write_str(" | ")?;
7300            }
7301            f.write_str("RDMA_ADDRESS")?;
7302            remaining &= !Self::RDMA_ADDRESS.0;
7303            first = false;
7304        }
7305        if remaining & Self::OH_NATIVE_BUFFER_BIT.0 != 0 {
7306            if !first {
7307                f.write_str(" | ")?;
7308            }
7309            f.write_str("OH_NATIVE_BUFFER_BIT")?;
7310            remaining &= !Self::OH_NATIVE_BUFFER_BIT.0;
7311            first = false;
7312        }
7313        if remaining & Self::SCREEN_BUFFER_BIT.0 != 0 {
7314            if !first {
7315                f.write_str(" | ")?;
7316            }
7317            f.write_str("SCREEN_BUFFER_BIT")?;
7318            remaining &= !Self::SCREEN_BUFFER_BIT.0;
7319            first = false;
7320        }
7321        if remaining & Self::MTLBUFFER.0 != 0 {
7322            if !first {
7323                f.write_str(" | ")?;
7324            }
7325            f.write_str("MTLBUFFER")?;
7326            remaining &= !Self::MTLBUFFER.0;
7327            first = false;
7328        }
7329        if remaining & Self::MTLTEXTURE.0 != 0 {
7330            if !first {
7331                f.write_str(" | ")?;
7332            }
7333            f.write_str("MTLTEXTURE")?;
7334            remaining &= !Self::MTLTEXTURE.0;
7335            first = false;
7336        }
7337        if remaining & Self::MTLHEAP.0 != 0 {
7338            if !first {
7339                f.write_str(" | ")?;
7340            }
7341            f.write_str("MTLHEAP")?;
7342            remaining &= !Self::MTLHEAP.0;
7343            first = false;
7344        }
7345        if remaining != 0u32 {
7346            if !first {
7347                f.write_str(" | ")?;
7348            }
7349            write!(f, "{:#x}", remaining)?;
7350        } else if first {
7351            f.write_str("(empty)")?;
7352        }
7353        Ok(())
7354    }
7355}
7356///[`VkExternalMemoryHandleTypeFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html)
7357#[repr(transparent)]
7358#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
7359#[doc(alias = "VkExternalMemoryHandleTypeFlagBitsNV")]
7360pub struct ExternalMemoryHandleTypeFlagBitsNV(u32);
7361impl ExternalMemoryHandleTypeFlagBitsNV {
7362    #[inline]
7363    pub const fn empty() -> Self {
7364        Self(0u32)
7365    }
7366    #[inline]
7367    pub const fn from_raw(value: u32) -> Self {
7368        Self(value)
7369    }
7370    #[inline]
7371    pub const fn as_raw(self) -> u32 {
7372        self.0
7373    }
7374    #[inline]
7375    pub const fn is_empty(self) -> bool {
7376        self.0 == 0u32
7377    }
7378    #[inline]
7379    pub const fn contains(self, other: Self) -> bool {
7380        (self.0 & other.0) == other.0
7381    }
7382    #[inline]
7383    pub const fn all() -> Self {
7384        Self(15u32)
7385    }
7386    ///Bit 0.
7387    pub const OPAQUE_WIN32: Self = Self(1u32);
7388    ///Bit 1.
7389    pub const OPAQUE_WIN32_KMT: Self = Self(2u32);
7390    ///Bit 2.
7391    pub const D3D11_IMAGE: Self = Self(4u32);
7392    ///Bit 3.
7393    pub const D3D11_IMAGE_KMT: Self = Self(8u32);
7394}
7395impl core::ops::BitOr for ExternalMemoryHandleTypeFlagBitsNV {
7396    type Output = Self;
7397    #[inline]
7398    fn bitor(self, rhs: Self) -> Self {
7399        Self(self.0 | rhs.0)
7400    }
7401}
7402impl core::ops::BitOrAssign for ExternalMemoryHandleTypeFlagBitsNV {
7403    #[inline]
7404    fn bitor_assign(&mut self, rhs: Self) {
7405        self.0 |= rhs.0;
7406    }
7407}
7408impl core::ops::BitAnd for ExternalMemoryHandleTypeFlagBitsNV {
7409    type Output = Self;
7410    #[inline]
7411    fn bitand(self, rhs: Self) -> Self {
7412        Self(self.0 & rhs.0)
7413    }
7414}
7415impl core::ops::BitAndAssign for ExternalMemoryHandleTypeFlagBitsNV {
7416    #[inline]
7417    fn bitand_assign(&mut self, rhs: Self) {
7418        self.0 &= rhs.0;
7419    }
7420}
7421impl core::ops::BitXor for ExternalMemoryHandleTypeFlagBitsNV {
7422    type Output = Self;
7423    #[inline]
7424    fn bitxor(self, rhs: Self) -> Self {
7425        Self(self.0 ^ rhs.0)
7426    }
7427}
7428impl core::ops::BitXorAssign for ExternalMemoryHandleTypeFlagBitsNV {
7429    #[inline]
7430    fn bitxor_assign(&mut self, rhs: Self) {
7431        self.0 ^= rhs.0;
7432    }
7433}
7434impl core::ops::Not for ExternalMemoryHandleTypeFlagBitsNV {
7435    type Output = Self;
7436    #[inline]
7437    fn not(self) -> Self {
7438        Self(!self.0)
7439    }
7440}
7441impl core::fmt::Debug for ExternalMemoryHandleTypeFlagBitsNV {
7442    #[allow(unused_mut, unused_variables)]
7443    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7444        let mut first = true;
7445        let mut remaining = self.0;
7446        if remaining & Self::OPAQUE_WIN32.0 != 0 {
7447            if !first {
7448                f.write_str(" | ")?;
7449            }
7450            f.write_str("OPAQUE_WIN32")?;
7451            remaining &= !Self::OPAQUE_WIN32.0;
7452            first = false;
7453        }
7454        if remaining & Self::OPAQUE_WIN32_KMT.0 != 0 {
7455            if !first {
7456                f.write_str(" | ")?;
7457            }
7458            f.write_str("OPAQUE_WIN32_KMT")?;
7459            remaining &= !Self::OPAQUE_WIN32_KMT.0;
7460            first = false;
7461        }
7462        if remaining & Self::D3D11_IMAGE.0 != 0 {
7463            if !first {
7464                f.write_str(" | ")?;
7465            }
7466            f.write_str("D3D11_IMAGE")?;
7467            remaining &= !Self::D3D11_IMAGE.0;
7468            first = false;
7469        }
7470        if remaining & Self::D3D11_IMAGE_KMT.0 != 0 {
7471            if !first {
7472                f.write_str(" | ")?;
7473            }
7474            f.write_str("D3D11_IMAGE_KMT")?;
7475            remaining &= !Self::D3D11_IMAGE_KMT.0;
7476            first = false;
7477        }
7478        if remaining != 0u32 {
7479            if !first {
7480                f.write_str(" | ")?;
7481            }
7482            write!(f, "{:#x}", remaining)?;
7483        } else if first {
7484            f.write_str("(empty)")?;
7485        }
7486        Ok(())
7487    }
7488}
7489///[`VkExternalSemaphoreFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreFeatureFlagBits.html)
7490#[repr(transparent)]
7491#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
7492#[doc(alias = "VkExternalSemaphoreFeatureFlagBits")]
7493pub struct ExternalSemaphoreFeatureFlagBits(u32);
7494impl ExternalSemaphoreFeatureFlagBits {
7495    #[inline]
7496    pub const fn empty() -> Self {
7497        Self(0u32)
7498    }
7499    #[inline]
7500    pub const fn from_raw(value: u32) -> Self {
7501        Self(value)
7502    }
7503    #[inline]
7504    pub const fn as_raw(self) -> u32 {
7505        self.0
7506    }
7507    #[inline]
7508    pub const fn is_empty(self) -> bool {
7509        self.0 == 0u32
7510    }
7511    #[inline]
7512    pub const fn contains(self, other: Self) -> bool {
7513        (self.0 & other.0) == other.0
7514    }
7515    #[inline]
7516    pub const fn all() -> Self {
7517        Self(3u32)
7518    }
7519    ///Bit 0.
7520    pub const EXPORTABLE: Self = Self(1u32);
7521    ///Bit 1.
7522    pub const IMPORTABLE: Self = Self(2u32);
7523}
7524impl core::ops::BitOr for ExternalSemaphoreFeatureFlagBits {
7525    type Output = Self;
7526    #[inline]
7527    fn bitor(self, rhs: Self) -> Self {
7528        Self(self.0 | rhs.0)
7529    }
7530}
7531impl core::ops::BitOrAssign for ExternalSemaphoreFeatureFlagBits {
7532    #[inline]
7533    fn bitor_assign(&mut self, rhs: Self) {
7534        self.0 |= rhs.0;
7535    }
7536}
7537impl core::ops::BitAnd for ExternalSemaphoreFeatureFlagBits {
7538    type Output = Self;
7539    #[inline]
7540    fn bitand(self, rhs: Self) -> Self {
7541        Self(self.0 & rhs.0)
7542    }
7543}
7544impl core::ops::BitAndAssign for ExternalSemaphoreFeatureFlagBits {
7545    #[inline]
7546    fn bitand_assign(&mut self, rhs: Self) {
7547        self.0 &= rhs.0;
7548    }
7549}
7550impl core::ops::BitXor for ExternalSemaphoreFeatureFlagBits {
7551    type Output = Self;
7552    #[inline]
7553    fn bitxor(self, rhs: Self) -> Self {
7554        Self(self.0 ^ rhs.0)
7555    }
7556}
7557impl core::ops::BitXorAssign for ExternalSemaphoreFeatureFlagBits {
7558    #[inline]
7559    fn bitxor_assign(&mut self, rhs: Self) {
7560        self.0 ^= rhs.0;
7561    }
7562}
7563impl core::ops::Not for ExternalSemaphoreFeatureFlagBits {
7564    type Output = Self;
7565    #[inline]
7566    fn not(self) -> Self {
7567        Self(!self.0)
7568    }
7569}
7570impl core::fmt::Debug for ExternalSemaphoreFeatureFlagBits {
7571    #[allow(unused_mut, unused_variables)]
7572    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7573        let mut first = true;
7574        let mut remaining = self.0;
7575        if remaining & Self::EXPORTABLE.0 != 0 {
7576            if !first {
7577                f.write_str(" | ")?;
7578            }
7579            f.write_str("EXPORTABLE")?;
7580            remaining &= !Self::EXPORTABLE.0;
7581            first = false;
7582        }
7583        if remaining & Self::IMPORTABLE.0 != 0 {
7584            if !first {
7585                f.write_str(" | ")?;
7586            }
7587            f.write_str("IMPORTABLE")?;
7588            remaining &= !Self::IMPORTABLE.0;
7589            first = false;
7590        }
7591        if remaining != 0u32 {
7592            if !first {
7593                f.write_str(" | ")?;
7594            }
7595            write!(f, "{:#x}", remaining)?;
7596        } else if first {
7597            f.write_str("(empty)")?;
7598        }
7599        Ok(())
7600    }
7601}
7602///[`VkExternalSemaphoreHandleTypeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreHandleTypeFlagBits.html)
7603#[repr(transparent)]
7604#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
7605#[doc(alias = "VkExternalSemaphoreHandleTypeFlagBits")]
7606pub struct ExternalSemaphoreHandleTypeFlagBits(u32);
7607impl ExternalSemaphoreHandleTypeFlagBits {
7608    #[inline]
7609    pub const fn empty() -> Self {
7610        Self(0u32)
7611    }
7612    #[inline]
7613    pub const fn from_raw(value: u32) -> Self {
7614        Self(value)
7615    }
7616    #[inline]
7617    pub const fn as_raw(self) -> u32 {
7618        self.0
7619    }
7620    #[inline]
7621    pub const fn is_empty(self) -> bool {
7622        self.0 == 0u32
7623    }
7624    #[inline]
7625    pub const fn contains(self, other: Self) -> bool {
7626        (self.0 & other.0) == other.0
7627    }
7628    #[inline]
7629    pub const fn all() -> Self {
7630        Self(159u32)
7631    }
7632    ///Bit 0.
7633    pub const OPAQUE_FD: Self = Self(1u32);
7634    ///Bit 1.
7635    pub const OPAQUE_WIN32: Self = Self(2u32);
7636    ///Bit 2.
7637    pub const OPAQUE_WIN32_KMT: Self = Self(4u32);
7638    ///Bit 3.
7639    pub const D3D12_FENCE: Self = Self(8u32);
7640    pub const D3D11_FENCE: Self = Self::D3D12_FENCE;
7641    ///Bit 4.
7642    pub const SYNC_FD: Self = Self(16u32);
7643    ///Bit 7.
7644    pub const ZIRCON_EVENT_BIT: Self = Self(128u32);
7645}
7646impl core::ops::BitOr for ExternalSemaphoreHandleTypeFlagBits {
7647    type Output = Self;
7648    #[inline]
7649    fn bitor(self, rhs: Self) -> Self {
7650        Self(self.0 | rhs.0)
7651    }
7652}
7653impl core::ops::BitOrAssign for ExternalSemaphoreHandleTypeFlagBits {
7654    #[inline]
7655    fn bitor_assign(&mut self, rhs: Self) {
7656        self.0 |= rhs.0;
7657    }
7658}
7659impl core::ops::BitAnd for ExternalSemaphoreHandleTypeFlagBits {
7660    type Output = Self;
7661    #[inline]
7662    fn bitand(self, rhs: Self) -> Self {
7663        Self(self.0 & rhs.0)
7664    }
7665}
7666impl core::ops::BitAndAssign for ExternalSemaphoreHandleTypeFlagBits {
7667    #[inline]
7668    fn bitand_assign(&mut self, rhs: Self) {
7669        self.0 &= rhs.0;
7670    }
7671}
7672impl core::ops::BitXor for ExternalSemaphoreHandleTypeFlagBits {
7673    type Output = Self;
7674    #[inline]
7675    fn bitxor(self, rhs: Self) -> Self {
7676        Self(self.0 ^ rhs.0)
7677    }
7678}
7679impl core::ops::BitXorAssign for ExternalSemaphoreHandleTypeFlagBits {
7680    #[inline]
7681    fn bitxor_assign(&mut self, rhs: Self) {
7682        self.0 ^= rhs.0;
7683    }
7684}
7685impl core::ops::Not for ExternalSemaphoreHandleTypeFlagBits {
7686    type Output = Self;
7687    #[inline]
7688    fn not(self) -> Self {
7689        Self(!self.0)
7690    }
7691}
7692impl core::fmt::Debug for ExternalSemaphoreHandleTypeFlagBits {
7693    #[allow(unused_mut, unused_variables)]
7694    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7695        let mut first = true;
7696        let mut remaining = self.0;
7697        if remaining & Self::OPAQUE_FD.0 != 0 {
7698            if !first {
7699                f.write_str(" | ")?;
7700            }
7701            f.write_str("OPAQUE_FD")?;
7702            remaining &= !Self::OPAQUE_FD.0;
7703            first = false;
7704        }
7705        if remaining & Self::OPAQUE_WIN32.0 != 0 {
7706            if !first {
7707                f.write_str(" | ")?;
7708            }
7709            f.write_str("OPAQUE_WIN32")?;
7710            remaining &= !Self::OPAQUE_WIN32.0;
7711            first = false;
7712        }
7713        if remaining & Self::OPAQUE_WIN32_KMT.0 != 0 {
7714            if !first {
7715                f.write_str(" | ")?;
7716            }
7717            f.write_str("OPAQUE_WIN32_KMT")?;
7718            remaining &= !Self::OPAQUE_WIN32_KMT.0;
7719            first = false;
7720        }
7721        if remaining & Self::D3D12_FENCE.0 != 0 {
7722            if !first {
7723                f.write_str(" | ")?;
7724            }
7725            f.write_str("D3D12_FENCE")?;
7726            remaining &= !Self::D3D12_FENCE.0;
7727            first = false;
7728        }
7729        if remaining & Self::SYNC_FD.0 != 0 {
7730            if !first {
7731                f.write_str(" | ")?;
7732            }
7733            f.write_str("SYNC_FD")?;
7734            remaining &= !Self::SYNC_FD.0;
7735            first = false;
7736        }
7737        if remaining & Self::ZIRCON_EVENT_BIT.0 != 0 {
7738            if !first {
7739                f.write_str(" | ")?;
7740            }
7741            f.write_str("ZIRCON_EVENT_BIT")?;
7742            remaining &= !Self::ZIRCON_EVENT_BIT.0;
7743            first = false;
7744        }
7745        if remaining != 0u32 {
7746            if !first {
7747                f.write_str(" | ")?;
7748            }
7749            write!(f, "{:#x}", remaining)?;
7750        } else if first {
7751            f.write_str("(empty)")?;
7752        }
7753        Ok(())
7754    }
7755}
7756///[`VkFenceCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceCreateFlagBits.html)
7757#[repr(transparent)]
7758#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
7759#[doc(alias = "VkFenceCreateFlagBits")]
7760pub struct FenceCreateFlagBits(u32);
7761impl FenceCreateFlagBits {
7762    #[inline]
7763    pub const fn empty() -> Self {
7764        Self(0u32)
7765    }
7766    #[inline]
7767    pub const fn from_raw(value: u32) -> Self {
7768        Self(value)
7769    }
7770    #[inline]
7771    pub const fn as_raw(self) -> u32 {
7772        self.0
7773    }
7774    #[inline]
7775    pub const fn is_empty(self) -> bool {
7776        self.0 == 0u32
7777    }
7778    #[inline]
7779    pub const fn contains(self, other: Self) -> bool {
7780        (self.0 & other.0) == other.0
7781    }
7782    #[inline]
7783    pub const fn all() -> Self {
7784        Self(1u32)
7785    }
7786    ///Bit 0.
7787    pub const SIGNALED: Self = Self(1u32);
7788}
7789impl core::ops::BitOr for FenceCreateFlagBits {
7790    type Output = Self;
7791    #[inline]
7792    fn bitor(self, rhs: Self) -> Self {
7793        Self(self.0 | rhs.0)
7794    }
7795}
7796impl core::ops::BitOrAssign for FenceCreateFlagBits {
7797    #[inline]
7798    fn bitor_assign(&mut self, rhs: Self) {
7799        self.0 |= rhs.0;
7800    }
7801}
7802impl core::ops::BitAnd for FenceCreateFlagBits {
7803    type Output = Self;
7804    #[inline]
7805    fn bitand(self, rhs: Self) -> Self {
7806        Self(self.0 & rhs.0)
7807    }
7808}
7809impl core::ops::BitAndAssign for FenceCreateFlagBits {
7810    #[inline]
7811    fn bitand_assign(&mut self, rhs: Self) {
7812        self.0 &= rhs.0;
7813    }
7814}
7815impl core::ops::BitXor for FenceCreateFlagBits {
7816    type Output = Self;
7817    #[inline]
7818    fn bitxor(self, rhs: Self) -> Self {
7819        Self(self.0 ^ rhs.0)
7820    }
7821}
7822impl core::ops::BitXorAssign for FenceCreateFlagBits {
7823    #[inline]
7824    fn bitxor_assign(&mut self, rhs: Self) {
7825        self.0 ^= rhs.0;
7826    }
7827}
7828impl core::ops::Not for FenceCreateFlagBits {
7829    type Output = Self;
7830    #[inline]
7831    fn not(self) -> Self {
7832        Self(!self.0)
7833    }
7834}
7835impl core::fmt::Debug for FenceCreateFlagBits {
7836    #[allow(unused_mut, unused_variables)]
7837    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7838        let mut first = true;
7839        let mut remaining = self.0;
7840        if remaining & Self::SIGNALED.0 != 0 {
7841            if !first {
7842                f.write_str(" | ")?;
7843            }
7844            f.write_str("SIGNALED")?;
7845            remaining &= !Self::SIGNALED.0;
7846            first = false;
7847        }
7848        if remaining != 0u32 {
7849            if !first {
7850                f.write_str(" | ")?;
7851            }
7852            write!(f, "{:#x}", remaining)?;
7853        } else if first {
7854            f.write_str("(empty)")?;
7855        }
7856        Ok(())
7857    }
7858}
7859///[`VkFenceImportFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceImportFlagBits.html)
7860#[repr(transparent)]
7861#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
7862#[doc(alias = "VkFenceImportFlagBits")]
7863pub struct FenceImportFlagBits(u32);
7864impl FenceImportFlagBits {
7865    #[inline]
7866    pub const fn empty() -> Self {
7867        Self(0u32)
7868    }
7869    #[inline]
7870    pub const fn from_raw(value: u32) -> Self {
7871        Self(value)
7872    }
7873    #[inline]
7874    pub const fn as_raw(self) -> u32 {
7875        self.0
7876    }
7877    #[inline]
7878    pub const fn is_empty(self) -> bool {
7879        self.0 == 0u32
7880    }
7881    #[inline]
7882    pub const fn contains(self, other: Self) -> bool {
7883        (self.0 & other.0) == other.0
7884    }
7885    #[inline]
7886    pub const fn all() -> Self {
7887        Self(1u32)
7888    }
7889    ///Bit 0.
7890    pub const TEMPORARY: Self = Self(1u32);
7891}
7892impl core::ops::BitOr for FenceImportFlagBits {
7893    type Output = Self;
7894    #[inline]
7895    fn bitor(self, rhs: Self) -> Self {
7896        Self(self.0 | rhs.0)
7897    }
7898}
7899impl core::ops::BitOrAssign for FenceImportFlagBits {
7900    #[inline]
7901    fn bitor_assign(&mut self, rhs: Self) {
7902        self.0 |= rhs.0;
7903    }
7904}
7905impl core::ops::BitAnd for FenceImportFlagBits {
7906    type Output = Self;
7907    #[inline]
7908    fn bitand(self, rhs: Self) -> Self {
7909        Self(self.0 & rhs.0)
7910    }
7911}
7912impl core::ops::BitAndAssign for FenceImportFlagBits {
7913    #[inline]
7914    fn bitand_assign(&mut self, rhs: Self) {
7915        self.0 &= rhs.0;
7916    }
7917}
7918impl core::ops::BitXor for FenceImportFlagBits {
7919    type Output = Self;
7920    #[inline]
7921    fn bitxor(self, rhs: Self) -> Self {
7922        Self(self.0 ^ rhs.0)
7923    }
7924}
7925impl core::ops::BitXorAssign for FenceImportFlagBits {
7926    #[inline]
7927    fn bitxor_assign(&mut self, rhs: Self) {
7928        self.0 ^= rhs.0;
7929    }
7930}
7931impl core::ops::Not for FenceImportFlagBits {
7932    type Output = Self;
7933    #[inline]
7934    fn not(self) -> Self {
7935        Self(!self.0)
7936    }
7937}
7938impl core::fmt::Debug for FenceImportFlagBits {
7939    #[allow(unused_mut, unused_variables)]
7940    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7941        let mut first = true;
7942        let mut remaining = self.0;
7943        if remaining & Self::TEMPORARY.0 != 0 {
7944            if !first {
7945                f.write_str(" | ")?;
7946            }
7947            f.write_str("TEMPORARY")?;
7948            remaining &= !Self::TEMPORARY.0;
7949            first = false;
7950        }
7951        if remaining != 0u32 {
7952            if !first {
7953                f.write_str(" | ")?;
7954            }
7955            write!(f, "{:#x}", remaining)?;
7956        } else if first {
7957            f.write_str("(empty)")?;
7958        }
7959        Ok(())
7960    }
7961}
7962///[`VkFormatFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits.html)
7963#[repr(transparent)]
7964#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
7965#[doc(alias = "VkFormatFeatureFlagBits")]
7966pub struct FormatFeatureFlagBits(u32);
7967impl FormatFeatureFlagBits {
7968    #[inline]
7969    pub const fn empty() -> Self {
7970        Self(0u32)
7971    }
7972    #[inline]
7973    pub const fn from_raw(value: u32) -> Self {
7974        Self(value)
7975    }
7976    #[inline]
7977    pub const fn as_raw(self) -> u32 {
7978        self.0
7979    }
7980    #[inline]
7981    pub const fn is_empty(self) -> bool {
7982        self.0 == 0u32
7983    }
7984    #[inline]
7985    pub const fn contains(self, other: Self) -> bool {
7986        (self.0 & other.0) == other.0
7987    }
7988    #[inline]
7989    pub const fn all() -> Self {
7990        Self(2147483647u32)
7991    }
7992    ///Bit 0.
7993    pub const SAMPLED_IMAGE: Self = Self(1u32);
7994    ///Bit 1.
7995    pub const STORAGE_IMAGE: Self = Self(2u32);
7996    ///Bit 2.
7997    pub const STORAGE_IMAGE_ATOMIC: Self = Self(4u32);
7998    ///Bit 3.
7999    pub const UNIFORM_TEXEL_BUFFER: Self = Self(8u32);
8000    ///Bit 4.
8001    pub const STORAGE_TEXEL_BUFFER: Self = Self(16u32);
8002    ///Bit 5.
8003    pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(32u32);
8004    ///Bit 6.
8005    pub const VERTEX_BUFFER: Self = Self(64u32);
8006    ///Bit 7.
8007    pub const COLOR_ATTACHMENT: Self = Self(128u32);
8008    ///Bit 8.
8009    pub const COLOR_ATTACHMENT_BLEND: Self = Self(256u32);
8010    ///Bit 9.
8011    pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(512u32);
8012    ///Bit 10.
8013    pub const BLIT_SRC: Self = Self(1024u32);
8014    ///Bit 11.
8015    pub const BLIT_DST: Self = Self(2048u32);
8016    ///Bit 12.
8017    pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(4096u32);
8018    ///Bit 14.
8019    pub const TRANSFER_SRC: Self = Self(16384u32);
8020    ///Bit 15.
8021    pub const TRANSFER_DST: Self = Self(32768u32);
8022    ///Bit 17.
8023    pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(131072u32);
8024    ///Bit 18.
8025    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(262144u32);
8026    ///Bit 19.
8027    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = Self(
8028        524288u32,
8029    );
8030    ///Bit 20.
8031    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = Self(
8032        1048576u32,
8033    );
8034    ///Bit 21.
8035    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = Self(
8036        2097152u32,
8037    );
8038    ///Bit 22.
8039    pub const DISJOINT: Self = Self(4194304u32);
8040    ///Bit 23.
8041    pub const COSITED_CHROMA_SAMPLES: Self = Self(8388608u32);
8042    ///Bit 16.
8043    pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(65536u32);
8044    pub const SAMPLED_IMAGE_FILTER_CUBIC_BIT: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC;
8045    ///Bit 25.
8046    pub const VIDEO_DECODE_OUTPUT: Self = Self(33554432u32);
8047    ///Bit 26.
8048    pub const VIDEO_DECODE_DPB: Self = Self(67108864u32);
8049    ///Bit 29.
8050    pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER: Self = Self(536870912u32);
8051    ///Bit 13.
8052    pub const SAMPLED_IMAGE_FILTER_CUBIC: Self = Self(8192u32);
8053    ///Bit 24.
8054    pub const FRAGMENT_DENSITY_MAP: Self = Self(16777216u32);
8055    ///Bit 30.
8056    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(1073741824u32);
8057    ///Bit 27.
8058    pub const VIDEO_ENCODE_INPUT: Self = Self(134217728u32);
8059    ///Bit 28.
8060    pub const VIDEO_ENCODE_DPB: Self = Self(268435456u32);
8061}
8062impl core::ops::BitOr for FormatFeatureFlagBits {
8063    type Output = Self;
8064    #[inline]
8065    fn bitor(self, rhs: Self) -> Self {
8066        Self(self.0 | rhs.0)
8067    }
8068}
8069impl core::ops::BitOrAssign for FormatFeatureFlagBits {
8070    #[inline]
8071    fn bitor_assign(&mut self, rhs: Self) {
8072        self.0 |= rhs.0;
8073    }
8074}
8075impl core::ops::BitAnd for FormatFeatureFlagBits {
8076    type Output = Self;
8077    #[inline]
8078    fn bitand(self, rhs: Self) -> Self {
8079        Self(self.0 & rhs.0)
8080    }
8081}
8082impl core::ops::BitAndAssign for FormatFeatureFlagBits {
8083    #[inline]
8084    fn bitand_assign(&mut self, rhs: Self) {
8085        self.0 &= rhs.0;
8086    }
8087}
8088impl core::ops::BitXor for FormatFeatureFlagBits {
8089    type Output = Self;
8090    #[inline]
8091    fn bitxor(self, rhs: Self) -> Self {
8092        Self(self.0 ^ rhs.0)
8093    }
8094}
8095impl core::ops::BitXorAssign for FormatFeatureFlagBits {
8096    #[inline]
8097    fn bitxor_assign(&mut self, rhs: Self) {
8098        self.0 ^= rhs.0;
8099    }
8100}
8101impl core::ops::Not for FormatFeatureFlagBits {
8102    type Output = Self;
8103    #[inline]
8104    fn not(self) -> Self {
8105        Self(!self.0)
8106    }
8107}
8108impl core::fmt::Debug for FormatFeatureFlagBits {
8109    #[allow(unused_mut, unused_variables)]
8110    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
8111        let mut first = true;
8112        let mut remaining = self.0;
8113        if remaining & Self::SAMPLED_IMAGE.0 != 0 {
8114            if !first {
8115                f.write_str(" | ")?;
8116            }
8117            f.write_str("SAMPLED_IMAGE")?;
8118            remaining &= !Self::SAMPLED_IMAGE.0;
8119            first = false;
8120        }
8121        if remaining & Self::STORAGE_IMAGE.0 != 0 {
8122            if !first {
8123                f.write_str(" | ")?;
8124            }
8125            f.write_str("STORAGE_IMAGE")?;
8126            remaining &= !Self::STORAGE_IMAGE.0;
8127            first = false;
8128        }
8129        if remaining & Self::STORAGE_IMAGE_ATOMIC.0 != 0 {
8130            if !first {
8131                f.write_str(" | ")?;
8132            }
8133            f.write_str("STORAGE_IMAGE_ATOMIC")?;
8134            remaining &= !Self::STORAGE_IMAGE_ATOMIC.0;
8135            first = false;
8136        }
8137        if remaining & Self::UNIFORM_TEXEL_BUFFER.0 != 0 {
8138            if !first {
8139                f.write_str(" | ")?;
8140            }
8141            f.write_str("UNIFORM_TEXEL_BUFFER")?;
8142            remaining &= !Self::UNIFORM_TEXEL_BUFFER.0;
8143            first = false;
8144        }
8145        if remaining & Self::STORAGE_TEXEL_BUFFER.0 != 0 {
8146            if !first {
8147                f.write_str(" | ")?;
8148            }
8149            f.write_str("STORAGE_TEXEL_BUFFER")?;
8150            remaining &= !Self::STORAGE_TEXEL_BUFFER.0;
8151            first = false;
8152        }
8153        if remaining & Self::STORAGE_TEXEL_BUFFER_ATOMIC.0 != 0 {
8154            if !first {
8155                f.write_str(" | ")?;
8156            }
8157            f.write_str("STORAGE_TEXEL_BUFFER_ATOMIC")?;
8158            remaining &= !Self::STORAGE_TEXEL_BUFFER_ATOMIC.0;
8159            first = false;
8160        }
8161        if remaining & Self::VERTEX_BUFFER.0 != 0 {
8162            if !first {
8163                f.write_str(" | ")?;
8164            }
8165            f.write_str("VERTEX_BUFFER")?;
8166            remaining &= !Self::VERTEX_BUFFER.0;
8167            first = false;
8168        }
8169        if remaining & Self::COLOR_ATTACHMENT.0 != 0 {
8170            if !first {
8171                f.write_str(" | ")?;
8172            }
8173            f.write_str("COLOR_ATTACHMENT")?;
8174            remaining &= !Self::COLOR_ATTACHMENT.0;
8175            first = false;
8176        }
8177        if remaining & Self::COLOR_ATTACHMENT_BLEND.0 != 0 {
8178            if !first {
8179                f.write_str(" | ")?;
8180            }
8181            f.write_str("COLOR_ATTACHMENT_BLEND")?;
8182            remaining &= !Self::COLOR_ATTACHMENT_BLEND.0;
8183            first = false;
8184        }
8185        if remaining & Self::DEPTH_STENCIL_ATTACHMENT.0 != 0 {
8186            if !first {
8187                f.write_str(" | ")?;
8188            }
8189            f.write_str("DEPTH_STENCIL_ATTACHMENT")?;
8190            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT.0;
8191            first = false;
8192        }
8193        if remaining & Self::BLIT_SRC.0 != 0 {
8194            if !first {
8195                f.write_str(" | ")?;
8196            }
8197            f.write_str("BLIT_SRC")?;
8198            remaining &= !Self::BLIT_SRC.0;
8199            first = false;
8200        }
8201        if remaining & Self::BLIT_DST.0 != 0 {
8202            if !first {
8203                f.write_str(" | ")?;
8204            }
8205            f.write_str("BLIT_DST")?;
8206            remaining &= !Self::BLIT_DST.0;
8207            first = false;
8208        }
8209        if remaining & Self::SAMPLED_IMAGE_FILTER_LINEAR.0 != 0 {
8210            if !first {
8211                f.write_str(" | ")?;
8212            }
8213            f.write_str("SAMPLED_IMAGE_FILTER_LINEAR")?;
8214            remaining &= !Self::SAMPLED_IMAGE_FILTER_LINEAR.0;
8215            first = false;
8216        }
8217        if remaining & Self::TRANSFER_SRC.0 != 0 {
8218            if !first {
8219                f.write_str(" | ")?;
8220            }
8221            f.write_str("TRANSFER_SRC")?;
8222            remaining &= !Self::TRANSFER_SRC.0;
8223            first = false;
8224        }
8225        if remaining & Self::TRANSFER_DST.0 != 0 {
8226            if !first {
8227                f.write_str(" | ")?;
8228            }
8229            f.write_str("TRANSFER_DST")?;
8230            remaining &= !Self::TRANSFER_DST.0;
8231            first = false;
8232        }
8233        if remaining & Self::MIDPOINT_CHROMA_SAMPLES.0 != 0 {
8234            if !first {
8235                f.write_str(" | ")?;
8236            }
8237            f.write_str("MIDPOINT_CHROMA_SAMPLES")?;
8238            remaining &= !Self::MIDPOINT_CHROMA_SAMPLES.0;
8239            first = false;
8240        }
8241        if remaining & Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0 != 0 {
8242            if !first {
8243                f.write_str(" | ")?;
8244            }
8245            f.write_str("SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER")?;
8246            remaining &= !Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0;
8247            first = false;
8248        }
8249        if remaining
8250            & Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER.0 != 0
8251        {
8252            if !first {
8253                f.write_str(" | ")?;
8254            }
8255            f.write_str(
8256                "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER",
8257            )?;
8258            remaining
8259                &= !Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER
8260                    .0;
8261            first = false;
8262        }
8263        if remaining
8264            & Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT.0 != 0
8265        {
8266            if !first {
8267                f.write_str(" | ")?;
8268            }
8269            f.write_str(
8270                "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT",
8271            )?;
8272            remaining
8273                &= !Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT
8274                    .0;
8275            first = false;
8276        }
8277        if remaining
8278            & Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
8279                .0 != 0
8280        {
8281            if !first {
8282                f.write_str(" | ")?;
8283            }
8284            f.write_str(
8285                "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE",
8286            )?;
8287            remaining
8288                &= !Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
8289                    .0;
8290            first = false;
8291        }
8292        if remaining & Self::DISJOINT.0 != 0 {
8293            if !first {
8294                f.write_str(" | ")?;
8295            }
8296            f.write_str("DISJOINT")?;
8297            remaining &= !Self::DISJOINT.0;
8298            first = false;
8299        }
8300        if remaining & Self::COSITED_CHROMA_SAMPLES.0 != 0 {
8301            if !first {
8302                f.write_str(" | ")?;
8303            }
8304            f.write_str("COSITED_CHROMA_SAMPLES")?;
8305            remaining &= !Self::COSITED_CHROMA_SAMPLES.0;
8306            first = false;
8307        }
8308        if remaining & Self::SAMPLED_IMAGE_FILTER_MINMAX.0 != 0 {
8309            if !first {
8310                f.write_str(" | ")?;
8311            }
8312            f.write_str("SAMPLED_IMAGE_FILTER_MINMAX")?;
8313            remaining &= !Self::SAMPLED_IMAGE_FILTER_MINMAX.0;
8314            first = false;
8315        }
8316        if remaining & Self::VIDEO_DECODE_OUTPUT.0 != 0 {
8317            if !first {
8318                f.write_str(" | ")?;
8319            }
8320            f.write_str("VIDEO_DECODE_OUTPUT")?;
8321            remaining &= !Self::VIDEO_DECODE_OUTPUT.0;
8322            first = false;
8323        }
8324        if remaining & Self::VIDEO_DECODE_DPB.0 != 0 {
8325            if !first {
8326                f.write_str(" | ")?;
8327            }
8328            f.write_str("VIDEO_DECODE_DPB")?;
8329            remaining &= !Self::VIDEO_DECODE_DPB.0;
8330            first = false;
8331        }
8332        if remaining & Self::ACCELERATION_STRUCTURE_VERTEX_BUFFER.0 != 0 {
8333            if !first {
8334                f.write_str(" | ")?;
8335            }
8336            f.write_str("ACCELERATION_STRUCTURE_VERTEX_BUFFER")?;
8337            remaining &= !Self::ACCELERATION_STRUCTURE_VERTEX_BUFFER.0;
8338            first = false;
8339        }
8340        if remaining & Self::SAMPLED_IMAGE_FILTER_CUBIC.0 != 0 {
8341            if !first {
8342                f.write_str(" | ")?;
8343            }
8344            f.write_str("SAMPLED_IMAGE_FILTER_CUBIC")?;
8345            remaining &= !Self::SAMPLED_IMAGE_FILTER_CUBIC.0;
8346            first = false;
8347        }
8348        if remaining & Self::FRAGMENT_DENSITY_MAP.0 != 0 {
8349            if !first {
8350                f.write_str(" | ")?;
8351            }
8352            f.write_str("FRAGMENT_DENSITY_MAP")?;
8353            remaining &= !Self::FRAGMENT_DENSITY_MAP.0;
8354            first = false;
8355        }
8356        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
8357            if !first {
8358                f.write_str(" | ")?;
8359            }
8360            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT")?;
8361            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0;
8362            first = false;
8363        }
8364        if remaining & Self::VIDEO_ENCODE_INPUT.0 != 0 {
8365            if !first {
8366                f.write_str(" | ")?;
8367            }
8368            f.write_str("VIDEO_ENCODE_INPUT")?;
8369            remaining &= !Self::VIDEO_ENCODE_INPUT.0;
8370            first = false;
8371        }
8372        if remaining & Self::VIDEO_ENCODE_DPB.0 != 0 {
8373            if !first {
8374                f.write_str(" | ")?;
8375            }
8376            f.write_str("VIDEO_ENCODE_DPB")?;
8377            remaining &= !Self::VIDEO_ENCODE_DPB.0;
8378            first = false;
8379        }
8380        if remaining != 0u32 {
8381            if !first {
8382                f.write_str(" | ")?;
8383            }
8384            write!(f, "{:#x}", remaining)?;
8385        } else if first {
8386            f.write_str("(empty)")?;
8387        }
8388        Ok(())
8389    }
8390}
8391///[`VkFormatFeatureFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits2.html)
8392#[repr(transparent)]
8393#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
8394#[doc(alias = "VkFormatFeatureFlagBits2")]
8395pub struct FormatFeatureFlagBits2(u64);
8396impl FormatFeatureFlagBits2 {
8397    #[inline]
8398    pub const fn empty() -> Self {
8399        Self(0u64)
8400    }
8401    #[inline]
8402    pub const fn from_raw(value: u64) -> Self {
8403        Self(value)
8404    }
8405    #[inline]
8406    pub const fn as_raw(self) -> u64 {
8407        self.0
8408    }
8409    #[inline]
8410    pub const fn is_empty(self) -> bool {
8411        self.0 == 0u64
8412    }
8413    #[inline]
8414    pub const fn contains(self, other: Self) -> bool {
8415        (self.0 & other.0) == other.0
8416    }
8417    #[inline]
8418    pub const fn all() -> Self {
8419        Self(648324832294862847u64)
8420    }
8421    ///Bit 0.
8422    pub const _2_SAMPLED_IMAGE: Self = Self(1u64);
8423    ///Bit 1.
8424    pub const _2_STORAGE_IMAGE: Self = Self(2u64);
8425    ///Bit 2.
8426    pub const _2_STORAGE_IMAGE_ATOMIC: Self = Self(4u64);
8427    ///Bit 3.
8428    pub const _2_UNIFORM_TEXEL_BUFFER: Self = Self(8u64);
8429    ///Bit 4.
8430    pub const _2_STORAGE_TEXEL_BUFFER: Self = Self(16u64);
8431    ///Bit 5.
8432    pub const _2_STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(32u64);
8433    ///Bit 6.
8434    pub const _2_VERTEX_BUFFER: Self = Self(64u64);
8435    ///Bit 7.
8436    pub const _2_COLOR_ATTACHMENT: Self = Self(128u64);
8437    ///Bit 8.
8438    pub const _2_COLOR_ATTACHMENT_BLEND: Self = Self(256u64);
8439    ///Bit 9.
8440    pub const _2_DEPTH_STENCIL_ATTACHMENT: Self = Self(512u64);
8441    ///Bit 10.
8442    pub const _2_BLIT_SRC: Self = Self(1024u64);
8443    ///Bit 11.
8444    pub const _2_BLIT_DST: Self = Self(2048u64);
8445    ///Bit 12.
8446    pub const _2_SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(4096u64);
8447    ///Bit 14.
8448    pub const _2_TRANSFER_SRC: Self = Self(16384u64);
8449    ///Bit 15.
8450    pub const _2_TRANSFER_DST: Self = Self(32768u64);
8451    ///Bit 16.
8452    pub const _2_SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(65536u64);
8453    ///Bit 17.
8454    pub const _2_MIDPOINT_CHROMA_SAMPLES: Self = Self(131072u64);
8455    ///Bit 18.
8456    pub const _2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(262144u64);
8457    ///Bit 19.
8458    pub const _2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = Self(
8459        524288u64,
8460    );
8461    ///Bit 20.
8462    pub const _2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = Self(
8463        1048576u64,
8464    );
8465    ///Bit 21.
8466    pub const _2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = Self(
8467        2097152u64,
8468    );
8469    ///Bit 22.
8470    pub const _2_DISJOINT: Self = Self(4194304u64);
8471    ///Bit 23.
8472    pub const _2_COSITED_CHROMA_SAMPLES: Self = Self(8388608u64);
8473    ///Bit 31.
8474    pub const _2_STORAGE_READ_WITHOUT_FORMAT: Self = Self(2147483648u64);
8475    ///Bit 32.
8476    pub const _2_STORAGE_WRITE_WITHOUT_FORMAT: Self = Self(4294967296u64);
8477    ///Bit 33.
8478    pub const _2_SAMPLED_IMAGE_DEPTH_COMPARISON: Self = Self(8589934592u64);
8479    ///Bit 13.
8480    pub const _2_SAMPLED_IMAGE_FILTER_CUBIC: Self = Self(8192u64);
8481    ///Bit 46.
8482    pub const _2_HOST_IMAGE_TRANSFER: Self = Self(70368744177664u64);
8483    ///Bit 25.
8484    pub const _2_VIDEO_DECODE_OUTPUT: Self = Self(33554432u64);
8485    ///Bit 26.
8486    pub const _2_VIDEO_DECODE_DPB: Self = Self(67108864u64);
8487    ///Bit 29.
8488    pub const _2_ACCELERATION_STRUCTURE_VERTEX_BUFFER: Self = Self(536870912u64);
8489    ///Bit 24.
8490    pub const _2_FRAGMENT_DENSITY_MAP: Self = Self(16777216u64);
8491    ///Bit 30.
8492    pub const _2_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(1073741824u64);
8493    ///Bit 27.
8494    pub const _2_VIDEO_ENCODE_INPUT: Self = Self(134217728u64);
8495    ///Bit 28.
8496    pub const _2_VIDEO_ENCODE_DPB: Self = Self(268435456u64);
8497    ///Bit 51.
8498    pub const _2_ACCELERATION_STRUCTURE_RADIUS_BUFFER: Self = Self(2251799813685248u64);
8499    ///Bit 38.
8500    pub const _2_LINEAR_COLOR_ATTACHMENT: Self = Self(274877906944u64);
8501    ///Bit 34.
8502    pub const _2_WEIGHT_IMAGE_BIT: Self = Self(17179869184u64);
8503    ///Bit 35.
8504    pub const _2_WEIGHT_SAMPLED_IMAGE_BIT: Self = Self(34359738368u64);
8505    ///Bit 36.
8506    pub const _2_BLOCK_MATCHING_BIT: Self = Self(68719476736u64);
8507    ///Bit 37.
8508    pub const _2_BOX_FILTER_SAMPLED_BIT: Self = Self(137438953472u64);
8509    ///Bit 39.
8510    pub const _2_TENSOR_SHADER_BIT: Self = Self(549755813888u64);
8511    ///Bit 43.
8512    pub const _2_TENSOR_IMAGE_ALIASING_BIT: Self = Self(8796093022208u64);
8513    ///Bit 40.
8514    pub const _2_OPTICAL_FLOW_IMAGE: Self = Self(1099511627776u64);
8515    ///Bit 41.
8516    pub const _2_OPTICAL_FLOW_VECTOR: Self = Self(2199023255552u64);
8517    ///Bit 42.
8518    pub const _2_OPTICAL_FLOW_COST: Self = Self(4398046511104u64);
8519    ///Bit 48.
8520    pub const _2_TENSOR_DATA_GRAPH_BIT: Self = Self(281474976710656u64);
8521    ///Bit 59.
8522    pub const _2_COPY_IMAGE_INDIRECT_DST: Self = Self(576460752303423488u64);
8523    ///Bit 49.
8524    pub const _2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP: Self = Self(562949953421312u64);
8525    ///Bit 50.
8526    pub const _2_VIDEO_ENCODE_EMPHASIS_MAP: Self = Self(1125899906842624u64);
8527    ///Bit 52.
8528    pub const _2_DEPTH_COPY_ON_COMPUTE_QUEUE: Self = Self(4503599627370496u64);
8529    ///Bit 53.
8530    pub const _2_DEPTH_COPY_ON_TRANSFER_QUEUE: Self = Self(9007199254740992u64);
8531    ///Bit 54.
8532    pub const _2_STENCIL_COPY_ON_COMPUTE_QUEUE: Self = Self(18014398509481984u64);
8533    ///Bit 55.
8534    pub const _2_STENCIL_COPY_ON_TRANSFER_QUEUE: Self = Self(36028797018963968u64);
8535}
8536impl core::ops::BitOr for FormatFeatureFlagBits2 {
8537    type Output = Self;
8538    #[inline]
8539    fn bitor(self, rhs: Self) -> Self {
8540        Self(self.0 | rhs.0)
8541    }
8542}
8543impl core::ops::BitOrAssign for FormatFeatureFlagBits2 {
8544    #[inline]
8545    fn bitor_assign(&mut self, rhs: Self) {
8546        self.0 |= rhs.0;
8547    }
8548}
8549impl core::ops::BitAnd for FormatFeatureFlagBits2 {
8550    type Output = Self;
8551    #[inline]
8552    fn bitand(self, rhs: Self) -> Self {
8553        Self(self.0 & rhs.0)
8554    }
8555}
8556impl core::ops::BitAndAssign for FormatFeatureFlagBits2 {
8557    #[inline]
8558    fn bitand_assign(&mut self, rhs: Self) {
8559        self.0 &= rhs.0;
8560    }
8561}
8562impl core::ops::BitXor for FormatFeatureFlagBits2 {
8563    type Output = Self;
8564    #[inline]
8565    fn bitxor(self, rhs: Self) -> Self {
8566        Self(self.0 ^ rhs.0)
8567    }
8568}
8569impl core::ops::BitXorAssign for FormatFeatureFlagBits2 {
8570    #[inline]
8571    fn bitxor_assign(&mut self, rhs: Self) {
8572        self.0 ^= rhs.0;
8573    }
8574}
8575impl core::ops::Not for FormatFeatureFlagBits2 {
8576    type Output = Self;
8577    #[inline]
8578    fn not(self) -> Self {
8579        Self(!self.0)
8580    }
8581}
8582impl core::fmt::Debug for FormatFeatureFlagBits2 {
8583    #[allow(unused_mut, unused_variables)]
8584    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
8585        let mut first = true;
8586        let mut remaining = self.0;
8587        if remaining & Self::_2_SAMPLED_IMAGE.0 != 0 {
8588            if !first {
8589                f.write_str(" | ")?;
8590            }
8591            f.write_str("_2_SAMPLED_IMAGE")?;
8592            remaining &= !Self::_2_SAMPLED_IMAGE.0;
8593            first = false;
8594        }
8595        if remaining & Self::_2_STORAGE_IMAGE.0 != 0 {
8596            if !first {
8597                f.write_str(" | ")?;
8598            }
8599            f.write_str("_2_STORAGE_IMAGE")?;
8600            remaining &= !Self::_2_STORAGE_IMAGE.0;
8601            first = false;
8602        }
8603        if remaining & Self::_2_STORAGE_IMAGE_ATOMIC.0 != 0 {
8604            if !first {
8605                f.write_str(" | ")?;
8606            }
8607            f.write_str("_2_STORAGE_IMAGE_ATOMIC")?;
8608            remaining &= !Self::_2_STORAGE_IMAGE_ATOMIC.0;
8609            first = false;
8610        }
8611        if remaining & Self::_2_UNIFORM_TEXEL_BUFFER.0 != 0 {
8612            if !first {
8613                f.write_str(" | ")?;
8614            }
8615            f.write_str("_2_UNIFORM_TEXEL_BUFFER")?;
8616            remaining &= !Self::_2_UNIFORM_TEXEL_BUFFER.0;
8617            first = false;
8618        }
8619        if remaining & Self::_2_STORAGE_TEXEL_BUFFER.0 != 0 {
8620            if !first {
8621                f.write_str(" | ")?;
8622            }
8623            f.write_str("_2_STORAGE_TEXEL_BUFFER")?;
8624            remaining &= !Self::_2_STORAGE_TEXEL_BUFFER.0;
8625            first = false;
8626        }
8627        if remaining & Self::_2_STORAGE_TEXEL_BUFFER_ATOMIC.0 != 0 {
8628            if !first {
8629                f.write_str(" | ")?;
8630            }
8631            f.write_str("_2_STORAGE_TEXEL_BUFFER_ATOMIC")?;
8632            remaining &= !Self::_2_STORAGE_TEXEL_BUFFER_ATOMIC.0;
8633            first = false;
8634        }
8635        if remaining & Self::_2_VERTEX_BUFFER.0 != 0 {
8636            if !first {
8637                f.write_str(" | ")?;
8638            }
8639            f.write_str("_2_VERTEX_BUFFER")?;
8640            remaining &= !Self::_2_VERTEX_BUFFER.0;
8641            first = false;
8642        }
8643        if remaining & Self::_2_COLOR_ATTACHMENT.0 != 0 {
8644            if !first {
8645                f.write_str(" | ")?;
8646            }
8647            f.write_str("_2_COLOR_ATTACHMENT")?;
8648            remaining &= !Self::_2_COLOR_ATTACHMENT.0;
8649            first = false;
8650        }
8651        if remaining & Self::_2_COLOR_ATTACHMENT_BLEND.0 != 0 {
8652            if !first {
8653                f.write_str(" | ")?;
8654            }
8655            f.write_str("_2_COLOR_ATTACHMENT_BLEND")?;
8656            remaining &= !Self::_2_COLOR_ATTACHMENT_BLEND.0;
8657            first = false;
8658        }
8659        if remaining & Self::_2_DEPTH_STENCIL_ATTACHMENT.0 != 0 {
8660            if !first {
8661                f.write_str(" | ")?;
8662            }
8663            f.write_str("_2_DEPTH_STENCIL_ATTACHMENT")?;
8664            remaining &= !Self::_2_DEPTH_STENCIL_ATTACHMENT.0;
8665            first = false;
8666        }
8667        if remaining & Self::_2_BLIT_SRC.0 != 0 {
8668            if !first {
8669                f.write_str(" | ")?;
8670            }
8671            f.write_str("_2_BLIT_SRC")?;
8672            remaining &= !Self::_2_BLIT_SRC.0;
8673            first = false;
8674        }
8675        if remaining & Self::_2_BLIT_DST.0 != 0 {
8676            if !first {
8677                f.write_str(" | ")?;
8678            }
8679            f.write_str("_2_BLIT_DST")?;
8680            remaining &= !Self::_2_BLIT_DST.0;
8681            first = false;
8682        }
8683        if remaining & Self::_2_SAMPLED_IMAGE_FILTER_LINEAR.0 != 0 {
8684            if !first {
8685                f.write_str(" | ")?;
8686            }
8687            f.write_str("_2_SAMPLED_IMAGE_FILTER_LINEAR")?;
8688            remaining &= !Self::_2_SAMPLED_IMAGE_FILTER_LINEAR.0;
8689            first = false;
8690        }
8691        if remaining & Self::_2_TRANSFER_SRC.0 != 0 {
8692            if !first {
8693                f.write_str(" | ")?;
8694            }
8695            f.write_str("_2_TRANSFER_SRC")?;
8696            remaining &= !Self::_2_TRANSFER_SRC.0;
8697            first = false;
8698        }
8699        if remaining & Self::_2_TRANSFER_DST.0 != 0 {
8700            if !first {
8701                f.write_str(" | ")?;
8702            }
8703            f.write_str("_2_TRANSFER_DST")?;
8704            remaining &= !Self::_2_TRANSFER_DST.0;
8705            first = false;
8706        }
8707        if remaining & Self::_2_SAMPLED_IMAGE_FILTER_MINMAX.0 != 0 {
8708            if !first {
8709                f.write_str(" | ")?;
8710            }
8711            f.write_str("_2_SAMPLED_IMAGE_FILTER_MINMAX")?;
8712            remaining &= !Self::_2_SAMPLED_IMAGE_FILTER_MINMAX.0;
8713            first = false;
8714        }
8715        if remaining & Self::_2_MIDPOINT_CHROMA_SAMPLES.0 != 0 {
8716            if !first {
8717                f.write_str(" | ")?;
8718            }
8719            f.write_str("_2_MIDPOINT_CHROMA_SAMPLES")?;
8720            remaining &= !Self::_2_MIDPOINT_CHROMA_SAMPLES.0;
8721            first = false;
8722        }
8723        if remaining & Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0 != 0 {
8724            if !first {
8725                f.write_str(" | ")?;
8726            }
8727            f.write_str("_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER")?;
8728            remaining &= !Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0;
8729            first = false;
8730        }
8731        if remaining
8732            & Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER.0
8733            != 0
8734        {
8735            if !first {
8736                f.write_str(" | ")?;
8737            }
8738            f.write_str(
8739                "_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER",
8740            )?;
8741            remaining
8742                &= !Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER
8743                    .0;
8744            first = false;
8745        }
8746        if remaining
8747            & Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT.0
8748            != 0
8749        {
8750            if !first {
8751                f.write_str(" | ")?;
8752            }
8753            f.write_str(
8754                "_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT",
8755            )?;
8756            remaining
8757                &= !Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT
8758                    .0;
8759            first = false;
8760        }
8761        if remaining
8762            & Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
8763                .0 != 0
8764        {
8765            if !first {
8766                f.write_str(" | ")?;
8767            }
8768            f.write_str(
8769                "_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE",
8770            )?;
8771            remaining
8772                &= !Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
8773                    .0;
8774            first = false;
8775        }
8776        if remaining & Self::_2_DISJOINT.0 != 0 {
8777            if !first {
8778                f.write_str(" | ")?;
8779            }
8780            f.write_str("_2_DISJOINT")?;
8781            remaining &= !Self::_2_DISJOINT.0;
8782            first = false;
8783        }
8784        if remaining & Self::_2_COSITED_CHROMA_SAMPLES.0 != 0 {
8785            if !first {
8786                f.write_str(" | ")?;
8787            }
8788            f.write_str("_2_COSITED_CHROMA_SAMPLES")?;
8789            remaining &= !Self::_2_COSITED_CHROMA_SAMPLES.0;
8790            first = false;
8791        }
8792        if remaining & Self::_2_STORAGE_READ_WITHOUT_FORMAT.0 != 0 {
8793            if !first {
8794                f.write_str(" | ")?;
8795            }
8796            f.write_str("_2_STORAGE_READ_WITHOUT_FORMAT")?;
8797            remaining &= !Self::_2_STORAGE_READ_WITHOUT_FORMAT.0;
8798            first = false;
8799        }
8800        if remaining & Self::_2_STORAGE_WRITE_WITHOUT_FORMAT.0 != 0 {
8801            if !first {
8802                f.write_str(" | ")?;
8803            }
8804            f.write_str("_2_STORAGE_WRITE_WITHOUT_FORMAT")?;
8805            remaining &= !Self::_2_STORAGE_WRITE_WITHOUT_FORMAT.0;
8806            first = false;
8807        }
8808        if remaining & Self::_2_SAMPLED_IMAGE_DEPTH_COMPARISON.0 != 0 {
8809            if !first {
8810                f.write_str(" | ")?;
8811            }
8812            f.write_str("_2_SAMPLED_IMAGE_DEPTH_COMPARISON")?;
8813            remaining &= !Self::_2_SAMPLED_IMAGE_DEPTH_COMPARISON.0;
8814            first = false;
8815        }
8816        if remaining & Self::_2_SAMPLED_IMAGE_FILTER_CUBIC.0 != 0 {
8817            if !first {
8818                f.write_str(" | ")?;
8819            }
8820            f.write_str("_2_SAMPLED_IMAGE_FILTER_CUBIC")?;
8821            remaining &= !Self::_2_SAMPLED_IMAGE_FILTER_CUBIC.0;
8822            first = false;
8823        }
8824        if remaining & Self::_2_HOST_IMAGE_TRANSFER.0 != 0 {
8825            if !first {
8826                f.write_str(" | ")?;
8827            }
8828            f.write_str("_2_HOST_IMAGE_TRANSFER")?;
8829            remaining &= !Self::_2_HOST_IMAGE_TRANSFER.0;
8830            first = false;
8831        }
8832        if remaining & Self::_2_VIDEO_DECODE_OUTPUT.0 != 0 {
8833            if !first {
8834                f.write_str(" | ")?;
8835            }
8836            f.write_str("_2_VIDEO_DECODE_OUTPUT")?;
8837            remaining &= !Self::_2_VIDEO_DECODE_OUTPUT.0;
8838            first = false;
8839        }
8840        if remaining & Self::_2_VIDEO_DECODE_DPB.0 != 0 {
8841            if !first {
8842                f.write_str(" | ")?;
8843            }
8844            f.write_str("_2_VIDEO_DECODE_DPB")?;
8845            remaining &= !Self::_2_VIDEO_DECODE_DPB.0;
8846            first = false;
8847        }
8848        if remaining & Self::_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER.0 != 0 {
8849            if !first {
8850                f.write_str(" | ")?;
8851            }
8852            f.write_str("_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER")?;
8853            remaining &= !Self::_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER.0;
8854            first = false;
8855        }
8856        if remaining & Self::_2_FRAGMENT_DENSITY_MAP.0 != 0 {
8857            if !first {
8858                f.write_str(" | ")?;
8859            }
8860            f.write_str("_2_FRAGMENT_DENSITY_MAP")?;
8861            remaining &= !Self::_2_FRAGMENT_DENSITY_MAP.0;
8862            first = false;
8863        }
8864        if remaining & Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
8865            if !first {
8866                f.write_str(" | ")?;
8867            }
8868            f.write_str("_2_FRAGMENT_SHADING_RATE_ATTACHMENT")?;
8869            remaining &= !Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT.0;
8870            first = false;
8871        }
8872        if remaining & Self::_2_VIDEO_ENCODE_INPUT.0 != 0 {
8873            if !first {
8874                f.write_str(" | ")?;
8875            }
8876            f.write_str("_2_VIDEO_ENCODE_INPUT")?;
8877            remaining &= !Self::_2_VIDEO_ENCODE_INPUT.0;
8878            first = false;
8879        }
8880        if remaining & Self::_2_VIDEO_ENCODE_DPB.0 != 0 {
8881            if !first {
8882                f.write_str(" | ")?;
8883            }
8884            f.write_str("_2_VIDEO_ENCODE_DPB")?;
8885            remaining &= !Self::_2_VIDEO_ENCODE_DPB.0;
8886            first = false;
8887        }
8888        if remaining & Self::_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER.0 != 0 {
8889            if !first {
8890                f.write_str(" | ")?;
8891            }
8892            f.write_str("_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER")?;
8893            remaining &= !Self::_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER.0;
8894            first = false;
8895        }
8896        if remaining & Self::_2_LINEAR_COLOR_ATTACHMENT.0 != 0 {
8897            if !first {
8898                f.write_str(" | ")?;
8899            }
8900            f.write_str("_2_LINEAR_COLOR_ATTACHMENT")?;
8901            remaining &= !Self::_2_LINEAR_COLOR_ATTACHMENT.0;
8902            first = false;
8903        }
8904        if remaining & Self::_2_WEIGHT_IMAGE_BIT.0 != 0 {
8905            if !first {
8906                f.write_str(" | ")?;
8907            }
8908            f.write_str("_2_WEIGHT_IMAGE_BIT")?;
8909            remaining &= !Self::_2_WEIGHT_IMAGE_BIT.0;
8910            first = false;
8911        }
8912        if remaining & Self::_2_WEIGHT_SAMPLED_IMAGE_BIT.0 != 0 {
8913            if !first {
8914                f.write_str(" | ")?;
8915            }
8916            f.write_str("_2_WEIGHT_SAMPLED_IMAGE_BIT")?;
8917            remaining &= !Self::_2_WEIGHT_SAMPLED_IMAGE_BIT.0;
8918            first = false;
8919        }
8920        if remaining & Self::_2_BLOCK_MATCHING_BIT.0 != 0 {
8921            if !first {
8922                f.write_str(" | ")?;
8923            }
8924            f.write_str("_2_BLOCK_MATCHING_BIT")?;
8925            remaining &= !Self::_2_BLOCK_MATCHING_BIT.0;
8926            first = false;
8927        }
8928        if remaining & Self::_2_BOX_FILTER_SAMPLED_BIT.0 != 0 {
8929            if !first {
8930                f.write_str(" | ")?;
8931            }
8932            f.write_str("_2_BOX_FILTER_SAMPLED_BIT")?;
8933            remaining &= !Self::_2_BOX_FILTER_SAMPLED_BIT.0;
8934            first = false;
8935        }
8936        if remaining & Self::_2_TENSOR_SHADER_BIT.0 != 0 {
8937            if !first {
8938                f.write_str(" | ")?;
8939            }
8940            f.write_str("_2_TENSOR_SHADER_BIT")?;
8941            remaining &= !Self::_2_TENSOR_SHADER_BIT.0;
8942            first = false;
8943        }
8944        if remaining & Self::_2_TENSOR_IMAGE_ALIASING_BIT.0 != 0 {
8945            if !first {
8946                f.write_str(" | ")?;
8947            }
8948            f.write_str("_2_TENSOR_IMAGE_ALIASING_BIT")?;
8949            remaining &= !Self::_2_TENSOR_IMAGE_ALIASING_BIT.0;
8950            first = false;
8951        }
8952        if remaining & Self::_2_OPTICAL_FLOW_IMAGE.0 != 0 {
8953            if !first {
8954                f.write_str(" | ")?;
8955            }
8956            f.write_str("_2_OPTICAL_FLOW_IMAGE")?;
8957            remaining &= !Self::_2_OPTICAL_FLOW_IMAGE.0;
8958            first = false;
8959        }
8960        if remaining & Self::_2_OPTICAL_FLOW_VECTOR.0 != 0 {
8961            if !first {
8962                f.write_str(" | ")?;
8963            }
8964            f.write_str("_2_OPTICAL_FLOW_VECTOR")?;
8965            remaining &= !Self::_2_OPTICAL_FLOW_VECTOR.0;
8966            first = false;
8967        }
8968        if remaining & Self::_2_OPTICAL_FLOW_COST.0 != 0 {
8969            if !first {
8970                f.write_str(" | ")?;
8971            }
8972            f.write_str("_2_OPTICAL_FLOW_COST")?;
8973            remaining &= !Self::_2_OPTICAL_FLOW_COST.0;
8974            first = false;
8975        }
8976        if remaining & Self::_2_TENSOR_DATA_GRAPH_BIT.0 != 0 {
8977            if !first {
8978                f.write_str(" | ")?;
8979            }
8980            f.write_str("_2_TENSOR_DATA_GRAPH_BIT")?;
8981            remaining &= !Self::_2_TENSOR_DATA_GRAPH_BIT.0;
8982            first = false;
8983        }
8984        if remaining & Self::_2_COPY_IMAGE_INDIRECT_DST.0 != 0 {
8985            if !first {
8986                f.write_str(" | ")?;
8987            }
8988            f.write_str("_2_COPY_IMAGE_INDIRECT_DST")?;
8989            remaining &= !Self::_2_COPY_IMAGE_INDIRECT_DST.0;
8990            first = false;
8991        }
8992        if remaining & Self::_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP.0 != 0 {
8993            if !first {
8994                f.write_str(" | ")?;
8995            }
8996            f.write_str("_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP")?;
8997            remaining &= !Self::_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP.0;
8998            first = false;
8999        }
9000        if remaining & Self::_2_VIDEO_ENCODE_EMPHASIS_MAP.0 != 0 {
9001            if !first {
9002                f.write_str(" | ")?;
9003            }
9004            f.write_str("_2_VIDEO_ENCODE_EMPHASIS_MAP")?;
9005            remaining &= !Self::_2_VIDEO_ENCODE_EMPHASIS_MAP.0;
9006            first = false;
9007        }
9008        if remaining & Self::_2_DEPTH_COPY_ON_COMPUTE_QUEUE.0 != 0 {
9009            if !first {
9010                f.write_str(" | ")?;
9011            }
9012            f.write_str("_2_DEPTH_COPY_ON_COMPUTE_QUEUE")?;
9013            remaining &= !Self::_2_DEPTH_COPY_ON_COMPUTE_QUEUE.0;
9014            first = false;
9015        }
9016        if remaining & Self::_2_DEPTH_COPY_ON_TRANSFER_QUEUE.0 != 0 {
9017            if !first {
9018                f.write_str(" | ")?;
9019            }
9020            f.write_str("_2_DEPTH_COPY_ON_TRANSFER_QUEUE")?;
9021            remaining &= !Self::_2_DEPTH_COPY_ON_TRANSFER_QUEUE.0;
9022            first = false;
9023        }
9024        if remaining & Self::_2_STENCIL_COPY_ON_COMPUTE_QUEUE.0 != 0 {
9025            if !first {
9026                f.write_str(" | ")?;
9027            }
9028            f.write_str("_2_STENCIL_COPY_ON_COMPUTE_QUEUE")?;
9029            remaining &= !Self::_2_STENCIL_COPY_ON_COMPUTE_QUEUE.0;
9030            first = false;
9031        }
9032        if remaining & Self::_2_STENCIL_COPY_ON_TRANSFER_QUEUE.0 != 0 {
9033            if !first {
9034                f.write_str(" | ")?;
9035            }
9036            f.write_str("_2_STENCIL_COPY_ON_TRANSFER_QUEUE")?;
9037            remaining &= !Self::_2_STENCIL_COPY_ON_TRANSFER_QUEUE.0;
9038            first = false;
9039        }
9040        if remaining != 0u64 {
9041            if !first {
9042                f.write_str(" | ")?;
9043            }
9044            write!(f, "{:#x}", remaining)?;
9045        } else if first {
9046            f.write_str("(empty)")?;
9047        }
9048        Ok(())
9049    }
9050}
9051///[`VkFrameBoundaryFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryFlagBitsEXT.html)
9052#[repr(transparent)]
9053#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9054#[doc(alias = "VkFrameBoundaryFlagBitsEXT")]
9055pub struct FrameBoundaryFlagBitsEXT(u32);
9056impl FrameBoundaryFlagBitsEXT {
9057    #[inline]
9058    pub const fn empty() -> Self {
9059        Self(0u32)
9060    }
9061    #[inline]
9062    pub const fn from_raw(value: u32) -> Self {
9063        Self(value)
9064    }
9065    #[inline]
9066    pub const fn as_raw(self) -> u32 {
9067        self.0
9068    }
9069    #[inline]
9070    pub const fn is_empty(self) -> bool {
9071        self.0 == 0u32
9072    }
9073    #[inline]
9074    pub const fn contains(self, other: Self) -> bool {
9075        (self.0 & other.0) == other.0
9076    }
9077    #[inline]
9078    pub const fn all() -> Self {
9079        Self(1u32)
9080    }
9081    ///Bit 0.
9082    pub const FRAME_END: Self = Self(1u32);
9083}
9084impl core::ops::BitOr for FrameBoundaryFlagBitsEXT {
9085    type Output = Self;
9086    #[inline]
9087    fn bitor(self, rhs: Self) -> Self {
9088        Self(self.0 | rhs.0)
9089    }
9090}
9091impl core::ops::BitOrAssign for FrameBoundaryFlagBitsEXT {
9092    #[inline]
9093    fn bitor_assign(&mut self, rhs: Self) {
9094        self.0 |= rhs.0;
9095    }
9096}
9097impl core::ops::BitAnd for FrameBoundaryFlagBitsEXT {
9098    type Output = Self;
9099    #[inline]
9100    fn bitand(self, rhs: Self) -> Self {
9101        Self(self.0 & rhs.0)
9102    }
9103}
9104impl core::ops::BitAndAssign for FrameBoundaryFlagBitsEXT {
9105    #[inline]
9106    fn bitand_assign(&mut self, rhs: Self) {
9107        self.0 &= rhs.0;
9108    }
9109}
9110impl core::ops::BitXor for FrameBoundaryFlagBitsEXT {
9111    type Output = Self;
9112    #[inline]
9113    fn bitxor(self, rhs: Self) -> Self {
9114        Self(self.0 ^ rhs.0)
9115    }
9116}
9117impl core::ops::BitXorAssign for FrameBoundaryFlagBitsEXT {
9118    #[inline]
9119    fn bitxor_assign(&mut self, rhs: Self) {
9120        self.0 ^= rhs.0;
9121    }
9122}
9123impl core::ops::Not for FrameBoundaryFlagBitsEXT {
9124    type Output = Self;
9125    #[inline]
9126    fn not(self) -> Self {
9127        Self(!self.0)
9128    }
9129}
9130impl core::fmt::Debug for FrameBoundaryFlagBitsEXT {
9131    #[allow(unused_mut, unused_variables)]
9132    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9133        let mut first = true;
9134        let mut remaining = self.0;
9135        if remaining & Self::FRAME_END.0 != 0 {
9136            if !first {
9137                f.write_str(" | ")?;
9138            }
9139            f.write_str("FRAME_END")?;
9140            remaining &= !Self::FRAME_END.0;
9141            first = false;
9142        }
9143        if remaining != 0u32 {
9144            if !first {
9145                f.write_str(" | ")?;
9146            }
9147            write!(f, "{:#x}", remaining)?;
9148        } else if first {
9149            f.write_str("(empty)")?;
9150        }
9151        Ok(())
9152    }
9153}
9154///[`VkFramebufferCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferCreateFlagBits.html)
9155#[repr(transparent)]
9156#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9157#[doc(alias = "VkFramebufferCreateFlagBits")]
9158pub struct FramebufferCreateFlagBits(u32);
9159impl FramebufferCreateFlagBits {
9160    #[inline]
9161    pub const fn empty() -> Self {
9162        Self(0u32)
9163    }
9164    #[inline]
9165    pub const fn from_raw(value: u32) -> Self {
9166        Self(value)
9167    }
9168    #[inline]
9169    pub const fn as_raw(self) -> u32 {
9170        self.0
9171    }
9172    #[inline]
9173    pub const fn is_empty(self) -> bool {
9174        self.0 == 0u32
9175    }
9176    #[inline]
9177    pub const fn contains(self, other: Self) -> bool {
9178        (self.0 & other.0) == other.0
9179    }
9180    #[inline]
9181    pub const fn all() -> Self {
9182        Self(1u32)
9183    }
9184    ///Bit 0.
9185    pub const IMAGELESS: Self = Self(1u32);
9186}
9187impl core::ops::BitOr for FramebufferCreateFlagBits {
9188    type Output = Self;
9189    #[inline]
9190    fn bitor(self, rhs: Self) -> Self {
9191        Self(self.0 | rhs.0)
9192    }
9193}
9194impl core::ops::BitOrAssign for FramebufferCreateFlagBits {
9195    #[inline]
9196    fn bitor_assign(&mut self, rhs: Self) {
9197        self.0 |= rhs.0;
9198    }
9199}
9200impl core::ops::BitAnd for FramebufferCreateFlagBits {
9201    type Output = Self;
9202    #[inline]
9203    fn bitand(self, rhs: Self) -> Self {
9204        Self(self.0 & rhs.0)
9205    }
9206}
9207impl core::ops::BitAndAssign for FramebufferCreateFlagBits {
9208    #[inline]
9209    fn bitand_assign(&mut self, rhs: Self) {
9210        self.0 &= rhs.0;
9211    }
9212}
9213impl core::ops::BitXor for FramebufferCreateFlagBits {
9214    type Output = Self;
9215    #[inline]
9216    fn bitxor(self, rhs: Self) -> Self {
9217        Self(self.0 ^ rhs.0)
9218    }
9219}
9220impl core::ops::BitXorAssign for FramebufferCreateFlagBits {
9221    #[inline]
9222    fn bitxor_assign(&mut self, rhs: Self) {
9223        self.0 ^= rhs.0;
9224    }
9225}
9226impl core::ops::Not for FramebufferCreateFlagBits {
9227    type Output = Self;
9228    #[inline]
9229    fn not(self) -> Self {
9230        Self(!self.0)
9231    }
9232}
9233impl core::fmt::Debug for FramebufferCreateFlagBits {
9234    #[allow(unused_mut, unused_variables)]
9235    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9236        let mut first = true;
9237        let mut remaining = self.0;
9238        if remaining & Self::IMAGELESS.0 != 0 {
9239            if !first {
9240                f.write_str(" | ")?;
9241            }
9242            f.write_str("IMAGELESS")?;
9243            remaining &= !Self::IMAGELESS.0;
9244            first = false;
9245        }
9246        if remaining != 0u32 {
9247            if !first {
9248                f.write_str(" | ")?;
9249            }
9250            write!(f, "{:#x}", remaining)?;
9251        } else if first {
9252            f.write_str("(empty)")?;
9253        }
9254        Ok(())
9255    }
9256}
9257///[`VkGeometryFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryFlagBitsKHR.html)
9258#[repr(transparent)]
9259#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9260#[doc(alias = "VkGeometryFlagBitsKHR")]
9261pub struct GeometryFlagBitsKHR(u32);
9262impl GeometryFlagBitsKHR {
9263    #[inline]
9264    pub const fn empty() -> Self {
9265        Self(0u32)
9266    }
9267    #[inline]
9268    pub const fn from_raw(value: u32) -> Self {
9269        Self(value)
9270    }
9271    #[inline]
9272    pub const fn as_raw(self) -> u32 {
9273        self.0
9274    }
9275    #[inline]
9276    pub const fn is_empty(self) -> bool {
9277        self.0 == 0u32
9278    }
9279    #[inline]
9280    pub const fn contains(self, other: Self) -> bool {
9281        (self.0 & other.0) == other.0
9282    }
9283    #[inline]
9284    pub const fn all() -> Self {
9285        Self(3u32)
9286    }
9287    ///Bit 0.
9288    pub const OPAQUE: Self = Self(1u32);
9289    ///Bit 1.
9290    pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(2u32);
9291}
9292impl core::ops::BitOr for GeometryFlagBitsKHR {
9293    type Output = Self;
9294    #[inline]
9295    fn bitor(self, rhs: Self) -> Self {
9296        Self(self.0 | rhs.0)
9297    }
9298}
9299impl core::ops::BitOrAssign for GeometryFlagBitsKHR {
9300    #[inline]
9301    fn bitor_assign(&mut self, rhs: Self) {
9302        self.0 |= rhs.0;
9303    }
9304}
9305impl core::ops::BitAnd for GeometryFlagBitsKHR {
9306    type Output = Self;
9307    #[inline]
9308    fn bitand(self, rhs: Self) -> Self {
9309        Self(self.0 & rhs.0)
9310    }
9311}
9312impl core::ops::BitAndAssign for GeometryFlagBitsKHR {
9313    #[inline]
9314    fn bitand_assign(&mut self, rhs: Self) {
9315        self.0 &= rhs.0;
9316    }
9317}
9318impl core::ops::BitXor for GeometryFlagBitsKHR {
9319    type Output = Self;
9320    #[inline]
9321    fn bitxor(self, rhs: Self) -> Self {
9322        Self(self.0 ^ rhs.0)
9323    }
9324}
9325impl core::ops::BitXorAssign for GeometryFlagBitsKHR {
9326    #[inline]
9327    fn bitxor_assign(&mut self, rhs: Self) {
9328        self.0 ^= rhs.0;
9329    }
9330}
9331impl core::ops::Not for GeometryFlagBitsKHR {
9332    type Output = Self;
9333    #[inline]
9334    fn not(self) -> Self {
9335        Self(!self.0)
9336    }
9337}
9338impl core::fmt::Debug for GeometryFlagBitsKHR {
9339    #[allow(unused_mut, unused_variables)]
9340    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9341        let mut first = true;
9342        let mut remaining = self.0;
9343        if remaining & Self::OPAQUE.0 != 0 {
9344            if !first {
9345                f.write_str(" | ")?;
9346            }
9347            f.write_str("OPAQUE")?;
9348            remaining &= !Self::OPAQUE.0;
9349            first = false;
9350        }
9351        if remaining & Self::NO_DUPLICATE_ANY_HIT_INVOCATION.0 != 0 {
9352            if !first {
9353                f.write_str(" | ")?;
9354            }
9355            f.write_str("NO_DUPLICATE_ANY_HIT_INVOCATION")?;
9356            remaining &= !Self::NO_DUPLICATE_ANY_HIT_INVOCATION.0;
9357            first = false;
9358        }
9359        if remaining != 0u32 {
9360            if !first {
9361                f.write_str(" | ")?;
9362            }
9363            write!(f, "{:#x}", remaining)?;
9364        } else if first {
9365            f.write_str("(empty)")?;
9366        }
9367        Ok(())
9368    }
9369}
9370///[`VkGeometryInstanceFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryInstanceFlagBitsKHR.html)
9371#[repr(transparent)]
9372#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9373#[doc(alias = "VkGeometryInstanceFlagBitsKHR")]
9374pub struct GeometryInstanceFlagBitsKHR(u32);
9375impl GeometryInstanceFlagBitsKHR {
9376    #[inline]
9377    pub const fn empty() -> Self {
9378        Self(0u32)
9379    }
9380    #[inline]
9381    pub const fn from_raw(value: u32) -> Self {
9382        Self(value)
9383    }
9384    #[inline]
9385    pub const fn as_raw(self) -> u32 {
9386        self.0
9387    }
9388    #[inline]
9389    pub const fn is_empty(self) -> bool {
9390        self.0 == 0u32
9391    }
9392    #[inline]
9393    pub const fn contains(self, other: Self) -> bool {
9394        (self.0 & other.0) == other.0
9395    }
9396    #[inline]
9397    pub const fn all() -> Self {
9398        Self(63u32)
9399    }
9400    ///Bit 0.
9401    pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(1u32);
9402    ///Bit 1.
9403    pub const TRIANGLE_FLIP_FACING: Self = Self(2u32);
9404    ///Bit 2.
9405    pub const FORCE_OPAQUE: Self = Self(4u32);
9406    ///Bit 3.
9407    pub const FORCE_NO_OPAQUE: Self = Self(8u32);
9408    pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = Self::TRIANGLE_FLIP_FACING;
9409    pub const TRIANGLE_CULL_DISABLE: Self = Self::TRIANGLE_FACING_CULL_DISABLE;
9410    ///Bit 4.
9411    pub const FORCE_OPACITY_MICROMAP_2_STATE: Self = Self(16u32);
9412    ///Bit 5.
9413    pub const DISABLE_OPACITY_MICROMAPS: Self = Self(32u32);
9414}
9415impl core::ops::BitOr for GeometryInstanceFlagBitsKHR {
9416    type Output = Self;
9417    #[inline]
9418    fn bitor(self, rhs: Self) -> Self {
9419        Self(self.0 | rhs.0)
9420    }
9421}
9422impl core::ops::BitOrAssign for GeometryInstanceFlagBitsKHR {
9423    #[inline]
9424    fn bitor_assign(&mut self, rhs: Self) {
9425        self.0 |= rhs.0;
9426    }
9427}
9428impl core::ops::BitAnd for GeometryInstanceFlagBitsKHR {
9429    type Output = Self;
9430    #[inline]
9431    fn bitand(self, rhs: Self) -> Self {
9432        Self(self.0 & rhs.0)
9433    }
9434}
9435impl core::ops::BitAndAssign for GeometryInstanceFlagBitsKHR {
9436    #[inline]
9437    fn bitand_assign(&mut self, rhs: Self) {
9438        self.0 &= rhs.0;
9439    }
9440}
9441impl core::ops::BitXor for GeometryInstanceFlagBitsKHR {
9442    type Output = Self;
9443    #[inline]
9444    fn bitxor(self, rhs: Self) -> Self {
9445        Self(self.0 ^ rhs.0)
9446    }
9447}
9448impl core::ops::BitXorAssign for GeometryInstanceFlagBitsKHR {
9449    #[inline]
9450    fn bitxor_assign(&mut self, rhs: Self) {
9451        self.0 ^= rhs.0;
9452    }
9453}
9454impl core::ops::Not for GeometryInstanceFlagBitsKHR {
9455    type Output = Self;
9456    #[inline]
9457    fn not(self) -> Self {
9458        Self(!self.0)
9459    }
9460}
9461impl core::fmt::Debug for GeometryInstanceFlagBitsKHR {
9462    #[allow(unused_mut, unused_variables)]
9463    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9464        let mut first = true;
9465        let mut remaining = self.0;
9466        if remaining & Self::TRIANGLE_FACING_CULL_DISABLE.0 != 0 {
9467            if !first {
9468                f.write_str(" | ")?;
9469            }
9470            f.write_str("TRIANGLE_FACING_CULL_DISABLE")?;
9471            remaining &= !Self::TRIANGLE_FACING_CULL_DISABLE.0;
9472            first = false;
9473        }
9474        if remaining & Self::TRIANGLE_FLIP_FACING.0 != 0 {
9475            if !first {
9476                f.write_str(" | ")?;
9477            }
9478            f.write_str("TRIANGLE_FLIP_FACING")?;
9479            remaining &= !Self::TRIANGLE_FLIP_FACING.0;
9480            first = false;
9481        }
9482        if remaining & Self::FORCE_OPAQUE.0 != 0 {
9483            if !first {
9484                f.write_str(" | ")?;
9485            }
9486            f.write_str("FORCE_OPAQUE")?;
9487            remaining &= !Self::FORCE_OPAQUE.0;
9488            first = false;
9489        }
9490        if remaining & Self::FORCE_NO_OPAQUE.0 != 0 {
9491            if !first {
9492                f.write_str(" | ")?;
9493            }
9494            f.write_str("FORCE_NO_OPAQUE")?;
9495            remaining &= !Self::FORCE_NO_OPAQUE.0;
9496            first = false;
9497        }
9498        if remaining & Self::FORCE_OPACITY_MICROMAP_2_STATE.0 != 0 {
9499            if !first {
9500                f.write_str(" | ")?;
9501            }
9502            f.write_str("FORCE_OPACITY_MICROMAP_2_STATE")?;
9503            remaining &= !Self::FORCE_OPACITY_MICROMAP_2_STATE.0;
9504            first = false;
9505        }
9506        if remaining & Self::DISABLE_OPACITY_MICROMAPS.0 != 0 {
9507            if !first {
9508                f.write_str(" | ")?;
9509            }
9510            f.write_str("DISABLE_OPACITY_MICROMAPS")?;
9511            remaining &= !Self::DISABLE_OPACITY_MICROMAPS.0;
9512            first = false;
9513        }
9514        if remaining != 0u32 {
9515            if !first {
9516                f.write_str(" | ")?;
9517            }
9518            write!(f, "{:#x}", remaining)?;
9519        } else if first {
9520            f.write_str("(empty)")?;
9521        }
9522        Ok(())
9523    }
9524}
9525///[`VkGraphicsPipelineLibraryFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryFlagBitsEXT.html)
9526#[repr(transparent)]
9527#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9528#[doc(alias = "VkGraphicsPipelineLibraryFlagBitsEXT")]
9529pub struct GraphicsPipelineLibraryFlagBitsEXT(u32);
9530impl GraphicsPipelineLibraryFlagBitsEXT {
9531    #[inline]
9532    pub const fn empty() -> Self {
9533        Self(0u32)
9534    }
9535    #[inline]
9536    pub const fn from_raw(value: u32) -> Self {
9537        Self(value)
9538    }
9539    #[inline]
9540    pub const fn as_raw(self) -> u32 {
9541        self.0
9542    }
9543    #[inline]
9544    pub const fn is_empty(self) -> bool {
9545        self.0 == 0u32
9546    }
9547    #[inline]
9548    pub const fn contains(self, other: Self) -> bool {
9549        (self.0 & other.0) == other.0
9550    }
9551    #[inline]
9552    pub const fn all() -> Self {
9553        Self(15u32)
9554    }
9555    ///Bit 0.
9556    pub const VERTEX_INPUT_INTERFACE: Self = Self(1u32);
9557    ///Bit 1.
9558    pub const PRE_RASTERIZATION_SHADERS: Self = Self(2u32);
9559    ///Bit 2.
9560    pub const FRAGMENT_SHADER: Self = Self(4u32);
9561    ///Bit 3.
9562    pub const FRAGMENT_OUTPUT_INTERFACE: Self = Self(8u32);
9563}
9564impl core::ops::BitOr for GraphicsPipelineLibraryFlagBitsEXT {
9565    type Output = Self;
9566    #[inline]
9567    fn bitor(self, rhs: Self) -> Self {
9568        Self(self.0 | rhs.0)
9569    }
9570}
9571impl core::ops::BitOrAssign for GraphicsPipelineLibraryFlagBitsEXT {
9572    #[inline]
9573    fn bitor_assign(&mut self, rhs: Self) {
9574        self.0 |= rhs.0;
9575    }
9576}
9577impl core::ops::BitAnd for GraphicsPipelineLibraryFlagBitsEXT {
9578    type Output = Self;
9579    #[inline]
9580    fn bitand(self, rhs: Self) -> Self {
9581        Self(self.0 & rhs.0)
9582    }
9583}
9584impl core::ops::BitAndAssign for GraphicsPipelineLibraryFlagBitsEXT {
9585    #[inline]
9586    fn bitand_assign(&mut self, rhs: Self) {
9587        self.0 &= rhs.0;
9588    }
9589}
9590impl core::ops::BitXor for GraphicsPipelineLibraryFlagBitsEXT {
9591    type Output = Self;
9592    #[inline]
9593    fn bitxor(self, rhs: Self) -> Self {
9594        Self(self.0 ^ rhs.0)
9595    }
9596}
9597impl core::ops::BitXorAssign for GraphicsPipelineLibraryFlagBitsEXT {
9598    #[inline]
9599    fn bitxor_assign(&mut self, rhs: Self) {
9600        self.0 ^= rhs.0;
9601    }
9602}
9603impl core::ops::Not for GraphicsPipelineLibraryFlagBitsEXT {
9604    type Output = Self;
9605    #[inline]
9606    fn not(self) -> Self {
9607        Self(!self.0)
9608    }
9609}
9610impl core::fmt::Debug for GraphicsPipelineLibraryFlagBitsEXT {
9611    #[allow(unused_mut, unused_variables)]
9612    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9613        let mut first = true;
9614        let mut remaining = self.0;
9615        if remaining & Self::VERTEX_INPUT_INTERFACE.0 != 0 {
9616            if !first {
9617                f.write_str(" | ")?;
9618            }
9619            f.write_str("VERTEX_INPUT_INTERFACE")?;
9620            remaining &= !Self::VERTEX_INPUT_INTERFACE.0;
9621            first = false;
9622        }
9623        if remaining & Self::PRE_RASTERIZATION_SHADERS.0 != 0 {
9624            if !first {
9625                f.write_str(" | ")?;
9626            }
9627            f.write_str("PRE_RASTERIZATION_SHADERS")?;
9628            remaining &= !Self::PRE_RASTERIZATION_SHADERS.0;
9629            first = false;
9630        }
9631        if remaining & Self::FRAGMENT_SHADER.0 != 0 {
9632            if !first {
9633                f.write_str(" | ")?;
9634            }
9635            f.write_str("FRAGMENT_SHADER")?;
9636            remaining &= !Self::FRAGMENT_SHADER.0;
9637            first = false;
9638        }
9639        if remaining & Self::FRAGMENT_OUTPUT_INTERFACE.0 != 0 {
9640            if !first {
9641                f.write_str(" | ")?;
9642            }
9643            f.write_str("FRAGMENT_OUTPUT_INTERFACE")?;
9644            remaining &= !Self::FRAGMENT_OUTPUT_INTERFACE.0;
9645            first = false;
9646        }
9647        if remaining != 0u32 {
9648            if !first {
9649                f.write_str(" | ")?;
9650            }
9651            write!(f, "{:#x}", remaining)?;
9652        } else if first {
9653            f.write_str("(empty)")?;
9654        }
9655        Ok(())
9656    }
9657}
9658///[`VkHostImageCopyFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageCopyFlagBits.html)
9659#[repr(transparent)]
9660#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9661#[doc(alias = "VkHostImageCopyFlagBits")]
9662pub struct HostImageCopyFlagBits(u32);
9663impl HostImageCopyFlagBits {
9664    #[inline]
9665    pub const fn empty() -> Self {
9666        Self(0u32)
9667    }
9668    #[inline]
9669    pub const fn from_raw(value: u32) -> Self {
9670        Self(value)
9671    }
9672    #[inline]
9673    pub const fn as_raw(self) -> u32 {
9674        self.0
9675    }
9676    #[inline]
9677    pub const fn is_empty(self) -> bool {
9678        self.0 == 0u32
9679    }
9680    #[inline]
9681    pub const fn contains(self, other: Self) -> bool {
9682        (self.0 & other.0) == other.0
9683    }
9684    #[inline]
9685    pub const fn all() -> Self {
9686        Self(1u32)
9687    }
9688    ///Bit 0.
9689    pub const MEMCPY: Self = Self(1u32);
9690}
9691impl core::ops::BitOr for HostImageCopyFlagBits {
9692    type Output = Self;
9693    #[inline]
9694    fn bitor(self, rhs: Self) -> Self {
9695        Self(self.0 | rhs.0)
9696    }
9697}
9698impl core::ops::BitOrAssign for HostImageCopyFlagBits {
9699    #[inline]
9700    fn bitor_assign(&mut self, rhs: Self) {
9701        self.0 |= rhs.0;
9702    }
9703}
9704impl core::ops::BitAnd for HostImageCopyFlagBits {
9705    type Output = Self;
9706    #[inline]
9707    fn bitand(self, rhs: Self) -> Self {
9708        Self(self.0 & rhs.0)
9709    }
9710}
9711impl core::ops::BitAndAssign for HostImageCopyFlagBits {
9712    #[inline]
9713    fn bitand_assign(&mut self, rhs: Self) {
9714        self.0 &= rhs.0;
9715    }
9716}
9717impl core::ops::BitXor for HostImageCopyFlagBits {
9718    type Output = Self;
9719    #[inline]
9720    fn bitxor(self, rhs: Self) -> Self {
9721        Self(self.0 ^ rhs.0)
9722    }
9723}
9724impl core::ops::BitXorAssign for HostImageCopyFlagBits {
9725    #[inline]
9726    fn bitxor_assign(&mut self, rhs: Self) {
9727        self.0 ^= rhs.0;
9728    }
9729}
9730impl core::ops::Not for HostImageCopyFlagBits {
9731    type Output = Self;
9732    #[inline]
9733    fn not(self) -> Self {
9734        Self(!self.0)
9735    }
9736}
9737impl core::fmt::Debug for HostImageCopyFlagBits {
9738    #[allow(unused_mut, unused_variables)]
9739    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9740        let mut first = true;
9741        let mut remaining = self.0;
9742        if remaining & Self::MEMCPY.0 != 0 {
9743            if !first {
9744                f.write_str(" | ")?;
9745            }
9746            f.write_str("MEMCPY")?;
9747            remaining &= !Self::MEMCPY.0;
9748            first = false;
9749        }
9750        if remaining != 0u32 {
9751            if !first {
9752                f.write_str(" | ")?;
9753            }
9754            write!(f, "{:#x}", remaining)?;
9755        } else if first {
9756            f.write_str("(empty)")?;
9757        }
9758        Ok(())
9759    }
9760}
9761///[`VkImageAspectFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageAspectFlagBits.html)
9762#[repr(transparent)]
9763#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9764#[doc(alias = "VkImageAspectFlagBits")]
9765pub struct ImageAspectFlagBits(u32);
9766impl ImageAspectFlagBits {
9767    #[inline]
9768    pub const fn empty() -> Self {
9769        Self(0u32)
9770    }
9771    #[inline]
9772    pub const fn from_raw(value: u32) -> Self {
9773        Self(value)
9774    }
9775    #[inline]
9776    pub const fn as_raw(self) -> u32 {
9777        self.0
9778    }
9779    #[inline]
9780    pub const fn is_empty(self) -> bool {
9781        self.0 == 0u32
9782    }
9783    #[inline]
9784    pub const fn contains(self, other: Self) -> bool {
9785        (self.0 & other.0) == other.0
9786    }
9787    #[inline]
9788    pub const fn all() -> Self {
9789        Self(2047u32)
9790    }
9791    ///Bit 0.
9792    pub const COLOR: Self = Self(1u32);
9793    ///Bit 1.
9794    pub const DEPTH: Self = Self(2u32);
9795    ///Bit 2.
9796    pub const STENCIL: Self = Self(4u32);
9797    ///Bit 3.
9798    pub const METADATA: Self = Self(8u32);
9799    ///Bit 4.
9800    pub const PLANE_0: Self = Self(16u32);
9801    ///Bit 5.
9802    pub const PLANE_1: Self = Self(32u32);
9803    ///Bit 6.
9804    pub const PLANE_2: Self = Self(64u32);
9805    pub const NONE: Self = Self(0u32);
9806    ///Bit 7.
9807    pub const MEMORY_PLANE_0: Self = Self(128u32);
9808    ///Bit 8.
9809    pub const MEMORY_PLANE_1: Self = Self(256u32);
9810    ///Bit 9.
9811    pub const MEMORY_PLANE_2: Self = Self(512u32);
9812    ///Bit 10.
9813    pub const MEMORY_PLANE_3: Self = Self(1024u32);
9814}
9815impl core::ops::BitOr for ImageAspectFlagBits {
9816    type Output = Self;
9817    #[inline]
9818    fn bitor(self, rhs: Self) -> Self {
9819        Self(self.0 | rhs.0)
9820    }
9821}
9822impl core::ops::BitOrAssign for ImageAspectFlagBits {
9823    #[inline]
9824    fn bitor_assign(&mut self, rhs: Self) {
9825        self.0 |= rhs.0;
9826    }
9827}
9828impl core::ops::BitAnd for ImageAspectFlagBits {
9829    type Output = Self;
9830    #[inline]
9831    fn bitand(self, rhs: Self) -> Self {
9832        Self(self.0 & rhs.0)
9833    }
9834}
9835impl core::ops::BitAndAssign for ImageAspectFlagBits {
9836    #[inline]
9837    fn bitand_assign(&mut self, rhs: Self) {
9838        self.0 &= rhs.0;
9839    }
9840}
9841impl core::ops::BitXor for ImageAspectFlagBits {
9842    type Output = Self;
9843    #[inline]
9844    fn bitxor(self, rhs: Self) -> Self {
9845        Self(self.0 ^ rhs.0)
9846    }
9847}
9848impl core::ops::BitXorAssign for ImageAspectFlagBits {
9849    #[inline]
9850    fn bitxor_assign(&mut self, rhs: Self) {
9851        self.0 ^= rhs.0;
9852    }
9853}
9854impl core::ops::Not for ImageAspectFlagBits {
9855    type Output = Self;
9856    #[inline]
9857    fn not(self) -> Self {
9858        Self(!self.0)
9859    }
9860}
9861impl core::fmt::Debug for ImageAspectFlagBits {
9862    #[allow(unused_mut, unused_variables)]
9863    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9864        let mut first = true;
9865        let mut remaining = self.0;
9866        if remaining & Self::COLOR.0 != 0 {
9867            if !first {
9868                f.write_str(" | ")?;
9869            }
9870            f.write_str("COLOR")?;
9871            remaining &= !Self::COLOR.0;
9872            first = false;
9873        }
9874        if remaining & Self::DEPTH.0 != 0 {
9875            if !first {
9876                f.write_str(" | ")?;
9877            }
9878            f.write_str("DEPTH")?;
9879            remaining &= !Self::DEPTH.0;
9880            first = false;
9881        }
9882        if remaining & Self::STENCIL.0 != 0 {
9883            if !first {
9884                f.write_str(" | ")?;
9885            }
9886            f.write_str("STENCIL")?;
9887            remaining &= !Self::STENCIL.0;
9888            first = false;
9889        }
9890        if remaining & Self::METADATA.0 != 0 {
9891            if !first {
9892                f.write_str(" | ")?;
9893            }
9894            f.write_str("METADATA")?;
9895            remaining &= !Self::METADATA.0;
9896            first = false;
9897        }
9898        if remaining & Self::PLANE_0.0 != 0 {
9899            if !first {
9900                f.write_str(" | ")?;
9901            }
9902            f.write_str("PLANE_0")?;
9903            remaining &= !Self::PLANE_0.0;
9904            first = false;
9905        }
9906        if remaining & Self::PLANE_1.0 != 0 {
9907            if !first {
9908                f.write_str(" | ")?;
9909            }
9910            f.write_str("PLANE_1")?;
9911            remaining &= !Self::PLANE_1.0;
9912            first = false;
9913        }
9914        if remaining & Self::PLANE_2.0 != 0 {
9915            if !first {
9916                f.write_str(" | ")?;
9917            }
9918            f.write_str("PLANE_2")?;
9919            remaining &= !Self::PLANE_2.0;
9920            first = false;
9921        }
9922        if remaining & Self::MEMORY_PLANE_0.0 != 0 {
9923            if !first {
9924                f.write_str(" | ")?;
9925            }
9926            f.write_str("MEMORY_PLANE_0")?;
9927            remaining &= !Self::MEMORY_PLANE_0.0;
9928            first = false;
9929        }
9930        if remaining & Self::MEMORY_PLANE_1.0 != 0 {
9931            if !first {
9932                f.write_str(" | ")?;
9933            }
9934            f.write_str("MEMORY_PLANE_1")?;
9935            remaining &= !Self::MEMORY_PLANE_1.0;
9936            first = false;
9937        }
9938        if remaining & Self::MEMORY_PLANE_2.0 != 0 {
9939            if !first {
9940                f.write_str(" | ")?;
9941            }
9942            f.write_str("MEMORY_PLANE_2")?;
9943            remaining &= !Self::MEMORY_PLANE_2.0;
9944            first = false;
9945        }
9946        if remaining & Self::MEMORY_PLANE_3.0 != 0 {
9947            if !first {
9948                f.write_str(" | ")?;
9949            }
9950            f.write_str("MEMORY_PLANE_3")?;
9951            remaining &= !Self::MEMORY_PLANE_3.0;
9952            first = false;
9953        }
9954        if remaining != 0u32 {
9955            if !first {
9956                f.write_str(" | ")?;
9957            }
9958            write!(f, "{:#x}", remaining)?;
9959        } else if first {
9960            f.write_str("(empty)")?;
9961        }
9962        Ok(())
9963    }
9964}
9965///[`VkImageCompressionFixedRateFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFixedRateFlagBitsEXT.html)
9966#[repr(transparent)]
9967#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9968#[doc(alias = "VkImageCompressionFixedRateFlagBitsEXT")]
9969pub struct ImageCompressionFixedRateFlagBitsEXT(u32);
9970impl ImageCompressionFixedRateFlagBitsEXT {
9971    #[inline]
9972    pub const fn empty() -> Self {
9973        Self(0u32)
9974    }
9975    #[inline]
9976    pub const fn from_raw(value: u32) -> Self {
9977        Self(value)
9978    }
9979    #[inline]
9980    pub const fn as_raw(self) -> u32 {
9981        self.0
9982    }
9983    #[inline]
9984    pub const fn is_empty(self) -> bool {
9985        self.0 == 0u32
9986    }
9987    #[inline]
9988    pub const fn contains(self, other: Self) -> bool {
9989        (self.0 & other.0) == other.0
9990    }
9991    #[inline]
9992    pub const fn all() -> Self {
9993        Self(16777215u32)
9994    }
9995    pub const NONE: Self = Self(0u32);
9996    ///Bit 0.
9997    pub const _1BPC: Self = Self(1u32);
9998    ///Bit 1.
9999    pub const _2BPC: Self = Self(2u32);
10000    ///Bit 2.
10001    pub const _3BPC: Self = Self(4u32);
10002    ///Bit 3.
10003    pub const _4BPC: Self = Self(8u32);
10004    ///Bit 4.
10005    pub const _5BPC: Self = Self(16u32);
10006    ///Bit 5.
10007    pub const _6BPC: Self = Self(32u32);
10008    ///Bit 6.
10009    pub const _7BPC: Self = Self(64u32);
10010    ///Bit 7.
10011    pub const _8BPC: Self = Self(128u32);
10012    ///Bit 8.
10013    pub const _9BPC: Self = Self(256u32);
10014    ///Bit 9.
10015    pub const _10BPC: Self = Self(512u32);
10016    ///Bit 10.
10017    pub const _11BPC: Self = Self(1024u32);
10018    ///Bit 11.
10019    pub const _12BPC: Self = Self(2048u32);
10020    ///Bit 12.
10021    pub const _13BPC: Self = Self(4096u32);
10022    ///Bit 13.
10023    pub const _14BPC: Self = Self(8192u32);
10024    ///Bit 14.
10025    pub const _15BPC: Self = Self(16384u32);
10026    ///Bit 15.
10027    pub const _16BPC: Self = Self(32768u32);
10028    ///Bit 16.
10029    pub const _17BPC: Self = Self(65536u32);
10030    ///Bit 17.
10031    pub const _18BPC: Self = Self(131072u32);
10032    ///Bit 18.
10033    pub const _19BPC: Self = Self(262144u32);
10034    ///Bit 19.
10035    pub const _20BPC: Self = Self(524288u32);
10036    ///Bit 20.
10037    pub const _21BPC: Self = Self(1048576u32);
10038    ///Bit 21.
10039    pub const _22BPC: Self = Self(2097152u32);
10040    ///Bit 22.
10041    pub const _23BPC: Self = Self(4194304u32);
10042    ///Bit 23.
10043    pub const _24BPC: Self = Self(8388608u32);
10044}
10045impl core::ops::BitOr for ImageCompressionFixedRateFlagBitsEXT {
10046    type Output = Self;
10047    #[inline]
10048    fn bitor(self, rhs: Self) -> Self {
10049        Self(self.0 | rhs.0)
10050    }
10051}
10052impl core::ops::BitOrAssign for ImageCompressionFixedRateFlagBitsEXT {
10053    #[inline]
10054    fn bitor_assign(&mut self, rhs: Self) {
10055        self.0 |= rhs.0;
10056    }
10057}
10058impl core::ops::BitAnd for ImageCompressionFixedRateFlagBitsEXT {
10059    type Output = Self;
10060    #[inline]
10061    fn bitand(self, rhs: Self) -> Self {
10062        Self(self.0 & rhs.0)
10063    }
10064}
10065impl core::ops::BitAndAssign for ImageCompressionFixedRateFlagBitsEXT {
10066    #[inline]
10067    fn bitand_assign(&mut self, rhs: Self) {
10068        self.0 &= rhs.0;
10069    }
10070}
10071impl core::ops::BitXor for ImageCompressionFixedRateFlagBitsEXT {
10072    type Output = Self;
10073    #[inline]
10074    fn bitxor(self, rhs: Self) -> Self {
10075        Self(self.0 ^ rhs.0)
10076    }
10077}
10078impl core::ops::BitXorAssign for ImageCompressionFixedRateFlagBitsEXT {
10079    #[inline]
10080    fn bitxor_assign(&mut self, rhs: Self) {
10081        self.0 ^= rhs.0;
10082    }
10083}
10084impl core::ops::Not for ImageCompressionFixedRateFlagBitsEXT {
10085    type Output = Self;
10086    #[inline]
10087    fn not(self) -> Self {
10088        Self(!self.0)
10089    }
10090}
10091impl core::fmt::Debug for ImageCompressionFixedRateFlagBitsEXT {
10092    #[allow(unused_mut, unused_variables)]
10093    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10094        let mut first = true;
10095        let mut remaining = self.0;
10096        if remaining & Self::_1BPC.0 != 0 {
10097            if !first {
10098                f.write_str(" | ")?;
10099            }
10100            f.write_str("_1BPC")?;
10101            remaining &= !Self::_1BPC.0;
10102            first = false;
10103        }
10104        if remaining & Self::_2BPC.0 != 0 {
10105            if !first {
10106                f.write_str(" | ")?;
10107            }
10108            f.write_str("_2BPC")?;
10109            remaining &= !Self::_2BPC.0;
10110            first = false;
10111        }
10112        if remaining & Self::_3BPC.0 != 0 {
10113            if !first {
10114                f.write_str(" | ")?;
10115            }
10116            f.write_str("_3BPC")?;
10117            remaining &= !Self::_3BPC.0;
10118            first = false;
10119        }
10120        if remaining & Self::_4BPC.0 != 0 {
10121            if !first {
10122                f.write_str(" | ")?;
10123            }
10124            f.write_str("_4BPC")?;
10125            remaining &= !Self::_4BPC.0;
10126            first = false;
10127        }
10128        if remaining & Self::_5BPC.0 != 0 {
10129            if !first {
10130                f.write_str(" | ")?;
10131            }
10132            f.write_str("_5BPC")?;
10133            remaining &= !Self::_5BPC.0;
10134            first = false;
10135        }
10136        if remaining & Self::_6BPC.0 != 0 {
10137            if !first {
10138                f.write_str(" | ")?;
10139            }
10140            f.write_str("_6BPC")?;
10141            remaining &= !Self::_6BPC.0;
10142            first = false;
10143        }
10144        if remaining & Self::_7BPC.0 != 0 {
10145            if !first {
10146                f.write_str(" | ")?;
10147            }
10148            f.write_str("_7BPC")?;
10149            remaining &= !Self::_7BPC.0;
10150            first = false;
10151        }
10152        if remaining & Self::_8BPC.0 != 0 {
10153            if !first {
10154                f.write_str(" | ")?;
10155            }
10156            f.write_str("_8BPC")?;
10157            remaining &= !Self::_8BPC.0;
10158            first = false;
10159        }
10160        if remaining & Self::_9BPC.0 != 0 {
10161            if !first {
10162                f.write_str(" | ")?;
10163            }
10164            f.write_str("_9BPC")?;
10165            remaining &= !Self::_9BPC.0;
10166            first = false;
10167        }
10168        if remaining & Self::_10BPC.0 != 0 {
10169            if !first {
10170                f.write_str(" | ")?;
10171            }
10172            f.write_str("_10BPC")?;
10173            remaining &= !Self::_10BPC.0;
10174            first = false;
10175        }
10176        if remaining & Self::_11BPC.0 != 0 {
10177            if !first {
10178                f.write_str(" | ")?;
10179            }
10180            f.write_str("_11BPC")?;
10181            remaining &= !Self::_11BPC.0;
10182            first = false;
10183        }
10184        if remaining & Self::_12BPC.0 != 0 {
10185            if !first {
10186                f.write_str(" | ")?;
10187            }
10188            f.write_str("_12BPC")?;
10189            remaining &= !Self::_12BPC.0;
10190            first = false;
10191        }
10192        if remaining & Self::_13BPC.0 != 0 {
10193            if !first {
10194                f.write_str(" | ")?;
10195            }
10196            f.write_str("_13BPC")?;
10197            remaining &= !Self::_13BPC.0;
10198            first = false;
10199        }
10200        if remaining & Self::_14BPC.0 != 0 {
10201            if !first {
10202                f.write_str(" | ")?;
10203            }
10204            f.write_str("_14BPC")?;
10205            remaining &= !Self::_14BPC.0;
10206            first = false;
10207        }
10208        if remaining & Self::_15BPC.0 != 0 {
10209            if !first {
10210                f.write_str(" | ")?;
10211            }
10212            f.write_str("_15BPC")?;
10213            remaining &= !Self::_15BPC.0;
10214            first = false;
10215        }
10216        if remaining & Self::_16BPC.0 != 0 {
10217            if !first {
10218                f.write_str(" | ")?;
10219            }
10220            f.write_str("_16BPC")?;
10221            remaining &= !Self::_16BPC.0;
10222            first = false;
10223        }
10224        if remaining & Self::_17BPC.0 != 0 {
10225            if !first {
10226                f.write_str(" | ")?;
10227            }
10228            f.write_str("_17BPC")?;
10229            remaining &= !Self::_17BPC.0;
10230            first = false;
10231        }
10232        if remaining & Self::_18BPC.0 != 0 {
10233            if !first {
10234                f.write_str(" | ")?;
10235            }
10236            f.write_str("_18BPC")?;
10237            remaining &= !Self::_18BPC.0;
10238            first = false;
10239        }
10240        if remaining & Self::_19BPC.0 != 0 {
10241            if !first {
10242                f.write_str(" | ")?;
10243            }
10244            f.write_str("_19BPC")?;
10245            remaining &= !Self::_19BPC.0;
10246            first = false;
10247        }
10248        if remaining & Self::_20BPC.0 != 0 {
10249            if !first {
10250                f.write_str(" | ")?;
10251            }
10252            f.write_str("_20BPC")?;
10253            remaining &= !Self::_20BPC.0;
10254            first = false;
10255        }
10256        if remaining & Self::_21BPC.0 != 0 {
10257            if !first {
10258                f.write_str(" | ")?;
10259            }
10260            f.write_str("_21BPC")?;
10261            remaining &= !Self::_21BPC.0;
10262            first = false;
10263        }
10264        if remaining & Self::_22BPC.0 != 0 {
10265            if !first {
10266                f.write_str(" | ")?;
10267            }
10268            f.write_str("_22BPC")?;
10269            remaining &= !Self::_22BPC.0;
10270            first = false;
10271        }
10272        if remaining & Self::_23BPC.0 != 0 {
10273            if !first {
10274                f.write_str(" | ")?;
10275            }
10276            f.write_str("_23BPC")?;
10277            remaining &= !Self::_23BPC.0;
10278            first = false;
10279        }
10280        if remaining & Self::_24BPC.0 != 0 {
10281            if !first {
10282                f.write_str(" | ")?;
10283            }
10284            f.write_str("_24BPC")?;
10285            remaining &= !Self::_24BPC.0;
10286            first = false;
10287        }
10288        if remaining != 0u32 {
10289            if !first {
10290                f.write_str(" | ")?;
10291            }
10292            write!(f, "{:#x}", remaining)?;
10293        } else if first {
10294            f.write_str("(empty)")?;
10295        }
10296        Ok(())
10297    }
10298}
10299///[`VkImageCompressionFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFlagBitsEXT.html)
10300#[repr(transparent)]
10301#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10302#[doc(alias = "VkImageCompressionFlagBitsEXT")]
10303pub struct ImageCompressionFlagBitsEXT(u32);
10304impl ImageCompressionFlagBitsEXT {
10305    #[inline]
10306    pub const fn empty() -> Self {
10307        Self(0u32)
10308    }
10309    #[inline]
10310    pub const fn from_raw(value: u32) -> Self {
10311        Self(value)
10312    }
10313    #[inline]
10314    pub const fn as_raw(self) -> u32 {
10315        self.0
10316    }
10317    #[inline]
10318    pub const fn is_empty(self) -> bool {
10319        self.0 == 0u32
10320    }
10321    #[inline]
10322    pub const fn contains(self, other: Self) -> bool {
10323        (self.0 & other.0) == other.0
10324    }
10325    #[inline]
10326    pub const fn all() -> Self {
10327        Self(7u32)
10328    }
10329    pub const DEFAULT: Self = Self(0u32);
10330    ///Bit 0.
10331    pub const FIXED_RATE_DEFAULT: Self = Self(1u32);
10332    ///Bit 1.
10333    pub const FIXED_RATE_EXPLICIT: Self = Self(2u32);
10334    ///Bit 2.
10335    pub const DISABLED: Self = Self(4u32);
10336}
10337impl core::ops::BitOr for ImageCompressionFlagBitsEXT {
10338    type Output = Self;
10339    #[inline]
10340    fn bitor(self, rhs: Self) -> Self {
10341        Self(self.0 | rhs.0)
10342    }
10343}
10344impl core::ops::BitOrAssign for ImageCompressionFlagBitsEXT {
10345    #[inline]
10346    fn bitor_assign(&mut self, rhs: Self) {
10347        self.0 |= rhs.0;
10348    }
10349}
10350impl core::ops::BitAnd for ImageCompressionFlagBitsEXT {
10351    type Output = Self;
10352    #[inline]
10353    fn bitand(self, rhs: Self) -> Self {
10354        Self(self.0 & rhs.0)
10355    }
10356}
10357impl core::ops::BitAndAssign for ImageCompressionFlagBitsEXT {
10358    #[inline]
10359    fn bitand_assign(&mut self, rhs: Self) {
10360        self.0 &= rhs.0;
10361    }
10362}
10363impl core::ops::BitXor for ImageCompressionFlagBitsEXT {
10364    type Output = Self;
10365    #[inline]
10366    fn bitxor(self, rhs: Self) -> Self {
10367        Self(self.0 ^ rhs.0)
10368    }
10369}
10370impl core::ops::BitXorAssign for ImageCompressionFlagBitsEXT {
10371    #[inline]
10372    fn bitxor_assign(&mut self, rhs: Self) {
10373        self.0 ^= rhs.0;
10374    }
10375}
10376impl core::ops::Not for ImageCompressionFlagBitsEXT {
10377    type Output = Self;
10378    #[inline]
10379    fn not(self) -> Self {
10380        Self(!self.0)
10381    }
10382}
10383impl core::fmt::Debug for ImageCompressionFlagBitsEXT {
10384    #[allow(unused_mut, unused_variables)]
10385    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10386        let mut first = true;
10387        let mut remaining = self.0;
10388        if remaining & Self::FIXED_RATE_DEFAULT.0 != 0 {
10389            if !first {
10390                f.write_str(" | ")?;
10391            }
10392            f.write_str("FIXED_RATE_DEFAULT")?;
10393            remaining &= !Self::FIXED_RATE_DEFAULT.0;
10394            first = false;
10395        }
10396        if remaining & Self::FIXED_RATE_EXPLICIT.0 != 0 {
10397            if !first {
10398                f.write_str(" | ")?;
10399            }
10400            f.write_str("FIXED_RATE_EXPLICIT")?;
10401            remaining &= !Self::FIXED_RATE_EXPLICIT.0;
10402            first = false;
10403        }
10404        if remaining & Self::DISABLED.0 != 0 {
10405            if !first {
10406                f.write_str(" | ")?;
10407            }
10408            f.write_str("DISABLED")?;
10409            remaining &= !Self::DISABLED.0;
10410            first = false;
10411        }
10412        if remaining != 0u32 {
10413            if !first {
10414                f.write_str(" | ")?;
10415            }
10416            write!(f, "{:#x}", remaining)?;
10417        } else if first {
10418            f.write_str("(empty)")?;
10419        }
10420        Ok(())
10421    }
10422}
10423///[`VkImageConstraintsInfoFlagBitsFUCHSIA`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html)
10424#[repr(transparent)]
10425#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10426#[doc(alias = "VkImageConstraintsInfoFlagBitsFUCHSIA")]
10427pub struct ImageConstraintsInfoFlagBitsFUCHSIA(u32);
10428impl ImageConstraintsInfoFlagBitsFUCHSIA {
10429    #[inline]
10430    pub const fn empty() -> Self {
10431        Self(0u32)
10432    }
10433    #[inline]
10434    pub const fn from_raw(value: u32) -> Self {
10435        Self(value)
10436    }
10437    #[inline]
10438    pub const fn as_raw(self) -> u32 {
10439        self.0
10440    }
10441    #[inline]
10442    pub const fn is_empty(self) -> bool {
10443        self.0 == 0u32
10444    }
10445    #[inline]
10446    pub const fn contains(self, other: Self) -> bool {
10447        (self.0 & other.0) == other.0
10448    }
10449    #[inline]
10450    pub const fn all() -> Self {
10451        Self(31u32)
10452    }
10453    ///Bit 0.
10454    pub const CPU_READ_RARELY: Self = Self(1u32);
10455    ///Bit 1.
10456    pub const CPU_READ_OFTEN: Self = Self(2u32);
10457    ///Bit 2.
10458    pub const CPU_WRITE_RARELY: Self = Self(4u32);
10459    ///Bit 3.
10460    pub const CPU_WRITE_OFTEN: Self = Self(8u32);
10461    ///Bit 4.
10462    pub const PROTECTED_OPTIONAL: Self = Self(16u32);
10463}
10464impl core::ops::BitOr for ImageConstraintsInfoFlagBitsFUCHSIA {
10465    type Output = Self;
10466    #[inline]
10467    fn bitor(self, rhs: Self) -> Self {
10468        Self(self.0 | rhs.0)
10469    }
10470}
10471impl core::ops::BitOrAssign for ImageConstraintsInfoFlagBitsFUCHSIA {
10472    #[inline]
10473    fn bitor_assign(&mut self, rhs: Self) {
10474        self.0 |= rhs.0;
10475    }
10476}
10477impl core::ops::BitAnd for ImageConstraintsInfoFlagBitsFUCHSIA {
10478    type Output = Self;
10479    #[inline]
10480    fn bitand(self, rhs: Self) -> Self {
10481        Self(self.0 & rhs.0)
10482    }
10483}
10484impl core::ops::BitAndAssign for ImageConstraintsInfoFlagBitsFUCHSIA {
10485    #[inline]
10486    fn bitand_assign(&mut self, rhs: Self) {
10487        self.0 &= rhs.0;
10488    }
10489}
10490impl core::ops::BitXor for ImageConstraintsInfoFlagBitsFUCHSIA {
10491    type Output = Self;
10492    #[inline]
10493    fn bitxor(self, rhs: Self) -> Self {
10494        Self(self.0 ^ rhs.0)
10495    }
10496}
10497impl core::ops::BitXorAssign for ImageConstraintsInfoFlagBitsFUCHSIA {
10498    #[inline]
10499    fn bitxor_assign(&mut self, rhs: Self) {
10500        self.0 ^= rhs.0;
10501    }
10502}
10503impl core::ops::Not for ImageConstraintsInfoFlagBitsFUCHSIA {
10504    type Output = Self;
10505    #[inline]
10506    fn not(self) -> Self {
10507        Self(!self.0)
10508    }
10509}
10510impl core::fmt::Debug for ImageConstraintsInfoFlagBitsFUCHSIA {
10511    #[allow(unused_mut, unused_variables)]
10512    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10513        let mut first = true;
10514        let mut remaining = self.0;
10515        if remaining & Self::CPU_READ_RARELY.0 != 0 {
10516            if !first {
10517                f.write_str(" | ")?;
10518            }
10519            f.write_str("CPU_READ_RARELY")?;
10520            remaining &= !Self::CPU_READ_RARELY.0;
10521            first = false;
10522        }
10523        if remaining & Self::CPU_READ_OFTEN.0 != 0 {
10524            if !first {
10525                f.write_str(" | ")?;
10526            }
10527            f.write_str("CPU_READ_OFTEN")?;
10528            remaining &= !Self::CPU_READ_OFTEN.0;
10529            first = false;
10530        }
10531        if remaining & Self::CPU_WRITE_RARELY.0 != 0 {
10532            if !first {
10533                f.write_str(" | ")?;
10534            }
10535            f.write_str("CPU_WRITE_RARELY")?;
10536            remaining &= !Self::CPU_WRITE_RARELY.0;
10537            first = false;
10538        }
10539        if remaining & Self::CPU_WRITE_OFTEN.0 != 0 {
10540            if !first {
10541                f.write_str(" | ")?;
10542            }
10543            f.write_str("CPU_WRITE_OFTEN")?;
10544            remaining &= !Self::CPU_WRITE_OFTEN.0;
10545            first = false;
10546        }
10547        if remaining & Self::PROTECTED_OPTIONAL.0 != 0 {
10548            if !first {
10549                f.write_str(" | ")?;
10550            }
10551            f.write_str("PROTECTED_OPTIONAL")?;
10552            remaining &= !Self::PROTECTED_OPTIONAL.0;
10553            first = false;
10554        }
10555        if remaining != 0u32 {
10556            if !first {
10557                f.write_str(" | ")?;
10558            }
10559            write!(f, "{:#x}", remaining)?;
10560        } else if first {
10561            f.write_str("(empty)")?;
10562        }
10563        Ok(())
10564    }
10565}
10566///[`VkImageCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlagBits.html)
10567#[repr(transparent)]
10568#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10569#[doc(alias = "VkImageCreateFlagBits")]
10570pub struct ImageCreateFlagBits(u32);
10571impl ImageCreateFlagBits {
10572    #[inline]
10573    pub const fn empty() -> Self {
10574        Self(0u32)
10575    }
10576    #[inline]
10577    pub const fn from_raw(value: u32) -> Self {
10578        Self(value)
10579    }
10580    #[inline]
10581    pub const fn as_raw(self) -> u32 {
10582        self.0
10583    }
10584    #[inline]
10585    pub const fn is_empty(self) -> bool {
10586        self.0 == 0u32
10587    }
10588    #[inline]
10589    pub const fn contains(self, other: Self) -> bool {
10590        (self.0 & other.0) == other.0
10591    }
10592    #[inline]
10593    pub const fn all() -> Self {
10594        Self(1572863u32)
10595    }
10596    ///Bit 0.
10597    pub const SPARSE_BINDING: Self = Self(1u32);
10598    ///Bit 1.
10599    pub const SPARSE_RESIDENCY: Self = Self(2u32);
10600    ///Bit 2.
10601    pub const SPARSE_ALIASED: Self = Self(4u32);
10602    ///Bit 3.
10603    pub const MUTABLE_FORMAT: Self = Self(8u32);
10604    ///Bit 4.
10605    pub const CUBE_COMPATIBLE: Self = Self(16u32);
10606    ///Bit 10.
10607    pub const ALIAS: Self = Self(1024u32);
10608    ///Bit 6.
10609    pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(64u32);
10610    ///Bit 5.
10611    pub const _2D_ARRAY_COMPATIBLE: Self = Self(32u32);
10612    ///Bit 7.
10613    pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = Self(128u32);
10614    ///Bit 8.
10615    pub const EXTENDED_USAGE: Self = Self(256u32);
10616    ///Bit 11.
10617    pub const PROTECTED: Self = Self(2048u32);
10618    ///Bit 9.
10619    pub const DISJOINT: Self = Self(512u32);
10620    ///Bit 13.
10621    pub const CORNER_SAMPLED: Self = Self(8192u32);
10622    ///Bit 16.
10623    pub const DESCRIPTOR_HEAP_CAPTURE_REPLAY: Self = Self(65536u32);
10624    ///Bit 12.
10625    pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH: Self = Self(4096u32);
10626    ///Bit 14.
10627    pub const SUBSAMPLED: Self = Self(16384u32);
10628    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY;
10629    ///Bit 18.
10630    pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED: Self = Self(262144u32);
10631    ///Bit 17.
10632    pub const _2D_VIEW_COMPATIBLE: Self = Self(131072u32);
10633    pub const FRAGMENT_DENSITY_MAP_OFFSET_BIT: Self = Self::FRAGMENT_DENSITY_MAP_OFFSET;
10634    ///Bit 20.
10635    pub const VIDEO_PROFILE_INDEPENDENT: Self = Self(1048576u32);
10636    ///Bit 15.
10637    pub const FRAGMENT_DENSITY_MAP_OFFSET: Self = Self(32768u32);
10638}
10639impl core::ops::BitOr for ImageCreateFlagBits {
10640    type Output = Self;
10641    #[inline]
10642    fn bitor(self, rhs: Self) -> Self {
10643        Self(self.0 | rhs.0)
10644    }
10645}
10646impl core::ops::BitOrAssign for ImageCreateFlagBits {
10647    #[inline]
10648    fn bitor_assign(&mut self, rhs: Self) {
10649        self.0 |= rhs.0;
10650    }
10651}
10652impl core::ops::BitAnd for ImageCreateFlagBits {
10653    type Output = Self;
10654    #[inline]
10655    fn bitand(self, rhs: Self) -> Self {
10656        Self(self.0 & rhs.0)
10657    }
10658}
10659impl core::ops::BitAndAssign for ImageCreateFlagBits {
10660    #[inline]
10661    fn bitand_assign(&mut self, rhs: Self) {
10662        self.0 &= rhs.0;
10663    }
10664}
10665impl core::ops::BitXor for ImageCreateFlagBits {
10666    type Output = Self;
10667    #[inline]
10668    fn bitxor(self, rhs: Self) -> Self {
10669        Self(self.0 ^ rhs.0)
10670    }
10671}
10672impl core::ops::BitXorAssign for ImageCreateFlagBits {
10673    #[inline]
10674    fn bitxor_assign(&mut self, rhs: Self) {
10675        self.0 ^= rhs.0;
10676    }
10677}
10678impl core::ops::Not for ImageCreateFlagBits {
10679    type Output = Self;
10680    #[inline]
10681    fn not(self) -> Self {
10682        Self(!self.0)
10683    }
10684}
10685impl core::fmt::Debug for ImageCreateFlagBits {
10686    #[allow(unused_mut, unused_variables)]
10687    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10688        let mut first = true;
10689        let mut remaining = self.0;
10690        if remaining & Self::SPARSE_BINDING.0 != 0 {
10691            if !first {
10692                f.write_str(" | ")?;
10693            }
10694            f.write_str("SPARSE_BINDING")?;
10695            remaining &= !Self::SPARSE_BINDING.0;
10696            first = false;
10697        }
10698        if remaining & Self::SPARSE_RESIDENCY.0 != 0 {
10699            if !first {
10700                f.write_str(" | ")?;
10701            }
10702            f.write_str("SPARSE_RESIDENCY")?;
10703            remaining &= !Self::SPARSE_RESIDENCY.0;
10704            first = false;
10705        }
10706        if remaining & Self::SPARSE_ALIASED.0 != 0 {
10707            if !first {
10708                f.write_str(" | ")?;
10709            }
10710            f.write_str("SPARSE_ALIASED")?;
10711            remaining &= !Self::SPARSE_ALIASED.0;
10712            first = false;
10713        }
10714        if remaining & Self::MUTABLE_FORMAT.0 != 0 {
10715            if !first {
10716                f.write_str(" | ")?;
10717            }
10718            f.write_str("MUTABLE_FORMAT")?;
10719            remaining &= !Self::MUTABLE_FORMAT.0;
10720            first = false;
10721        }
10722        if remaining & Self::CUBE_COMPATIBLE.0 != 0 {
10723            if !first {
10724                f.write_str(" | ")?;
10725            }
10726            f.write_str("CUBE_COMPATIBLE")?;
10727            remaining &= !Self::CUBE_COMPATIBLE.0;
10728            first = false;
10729        }
10730        if remaining & Self::ALIAS.0 != 0 {
10731            if !first {
10732                f.write_str(" | ")?;
10733            }
10734            f.write_str("ALIAS")?;
10735            remaining &= !Self::ALIAS.0;
10736            first = false;
10737        }
10738        if remaining & Self::SPLIT_INSTANCE_BIND_REGIONS.0 != 0 {
10739            if !first {
10740                f.write_str(" | ")?;
10741            }
10742            f.write_str("SPLIT_INSTANCE_BIND_REGIONS")?;
10743            remaining &= !Self::SPLIT_INSTANCE_BIND_REGIONS.0;
10744            first = false;
10745        }
10746        if remaining & Self::_2D_ARRAY_COMPATIBLE.0 != 0 {
10747            if !first {
10748                f.write_str(" | ")?;
10749            }
10750            f.write_str("_2D_ARRAY_COMPATIBLE")?;
10751            remaining &= !Self::_2D_ARRAY_COMPATIBLE.0;
10752            first = false;
10753        }
10754        if remaining & Self::BLOCK_TEXEL_VIEW_COMPATIBLE.0 != 0 {
10755            if !first {
10756                f.write_str(" | ")?;
10757            }
10758            f.write_str("BLOCK_TEXEL_VIEW_COMPATIBLE")?;
10759            remaining &= !Self::BLOCK_TEXEL_VIEW_COMPATIBLE.0;
10760            first = false;
10761        }
10762        if remaining & Self::EXTENDED_USAGE.0 != 0 {
10763            if !first {
10764                f.write_str(" | ")?;
10765            }
10766            f.write_str("EXTENDED_USAGE")?;
10767            remaining &= !Self::EXTENDED_USAGE.0;
10768            first = false;
10769        }
10770        if remaining & Self::PROTECTED.0 != 0 {
10771            if !first {
10772                f.write_str(" | ")?;
10773            }
10774            f.write_str("PROTECTED")?;
10775            remaining &= !Self::PROTECTED.0;
10776            first = false;
10777        }
10778        if remaining & Self::DISJOINT.0 != 0 {
10779            if !first {
10780                f.write_str(" | ")?;
10781            }
10782            f.write_str("DISJOINT")?;
10783            remaining &= !Self::DISJOINT.0;
10784            first = false;
10785        }
10786        if remaining & Self::CORNER_SAMPLED.0 != 0 {
10787            if !first {
10788                f.write_str(" | ")?;
10789            }
10790            f.write_str("CORNER_SAMPLED")?;
10791            remaining &= !Self::CORNER_SAMPLED.0;
10792            first = false;
10793        }
10794        if remaining & Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY.0 != 0 {
10795            if !first {
10796                f.write_str(" | ")?;
10797            }
10798            f.write_str("DESCRIPTOR_HEAP_CAPTURE_REPLAY")?;
10799            remaining &= !Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY.0;
10800            first = false;
10801        }
10802        if remaining & Self::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH.0 != 0 {
10803            if !first {
10804                f.write_str(" | ")?;
10805            }
10806            f.write_str("SAMPLE_LOCATIONS_COMPATIBLE_DEPTH")?;
10807            remaining &= !Self::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH.0;
10808            first = false;
10809        }
10810        if remaining & Self::SUBSAMPLED.0 != 0 {
10811            if !first {
10812                f.write_str(" | ")?;
10813            }
10814            f.write_str("SUBSAMPLED")?;
10815            remaining &= !Self::SUBSAMPLED.0;
10816            first = false;
10817        }
10818        if remaining & Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED.0 != 0 {
10819            if !first {
10820                f.write_str(" | ")?;
10821            }
10822            f.write_str("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED")?;
10823            remaining &= !Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED.0;
10824            first = false;
10825        }
10826        if remaining & Self::_2D_VIEW_COMPATIBLE.0 != 0 {
10827            if !first {
10828                f.write_str(" | ")?;
10829            }
10830            f.write_str("_2D_VIEW_COMPATIBLE")?;
10831            remaining &= !Self::_2D_VIEW_COMPATIBLE.0;
10832            first = false;
10833        }
10834        if remaining & Self::VIDEO_PROFILE_INDEPENDENT.0 != 0 {
10835            if !first {
10836                f.write_str(" | ")?;
10837            }
10838            f.write_str("VIDEO_PROFILE_INDEPENDENT")?;
10839            remaining &= !Self::VIDEO_PROFILE_INDEPENDENT.0;
10840            first = false;
10841        }
10842        if remaining & Self::FRAGMENT_DENSITY_MAP_OFFSET.0 != 0 {
10843            if !first {
10844                f.write_str(" | ")?;
10845            }
10846            f.write_str("FRAGMENT_DENSITY_MAP_OFFSET")?;
10847            remaining &= !Self::FRAGMENT_DENSITY_MAP_OFFSET.0;
10848            first = false;
10849        }
10850        if remaining != 0u32 {
10851            if !first {
10852                f.write_str(" | ")?;
10853            }
10854            write!(f, "{:#x}", remaining)?;
10855        } else if first {
10856            f.write_str("(empty)")?;
10857        }
10858        Ok(())
10859    }
10860}
10861///[`VkImageFormatConstraintsFlagBitsFUCHSIA`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html)
10862#[repr(transparent)]
10863#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10864#[doc(alias = "VkImageFormatConstraintsFlagBitsFUCHSIA")]
10865pub struct ImageFormatConstraintsFlagBitsFUCHSIA(u32);
10866impl ImageFormatConstraintsFlagBitsFUCHSIA {
10867    #[inline]
10868    pub const fn empty() -> Self {
10869        Self(0u32)
10870    }
10871    #[inline]
10872    pub const fn from_raw(value: u32) -> Self {
10873        Self(value)
10874    }
10875    #[inline]
10876    pub const fn as_raw(self) -> u32 {
10877        self.0
10878    }
10879    #[inline]
10880    pub const fn is_empty(self) -> bool {
10881        self.0 == 0u32
10882    }
10883    #[inline]
10884    pub const fn contains(self, other: Self) -> bool {
10885        (self.0 & other.0) == other.0
10886    }
10887    #[inline]
10888    pub const fn all() -> Self {
10889        Self(0u32)
10890    }
10891}
10892impl core::ops::BitOr for ImageFormatConstraintsFlagBitsFUCHSIA {
10893    type Output = Self;
10894    #[inline]
10895    fn bitor(self, rhs: Self) -> Self {
10896        Self(self.0 | rhs.0)
10897    }
10898}
10899impl core::ops::BitOrAssign for ImageFormatConstraintsFlagBitsFUCHSIA {
10900    #[inline]
10901    fn bitor_assign(&mut self, rhs: Self) {
10902        self.0 |= rhs.0;
10903    }
10904}
10905impl core::ops::BitAnd for ImageFormatConstraintsFlagBitsFUCHSIA {
10906    type Output = Self;
10907    #[inline]
10908    fn bitand(self, rhs: Self) -> Self {
10909        Self(self.0 & rhs.0)
10910    }
10911}
10912impl core::ops::BitAndAssign for ImageFormatConstraintsFlagBitsFUCHSIA {
10913    #[inline]
10914    fn bitand_assign(&mut self, rhs: Self) {
10915        self.0 &= rhs.0;
10916    }
10917}
10918impl core::ops::BitXor for ImageFormatConstraintsFlagBitsFUCHSIA {
10919    type Output = Self;
10920    #[inline]
10921    fn bitxor(self, rhs: Self) -> Self {
10922        Self(self.0 ^ rhs.0)
10923    }
10924}
10925impl core::ops::BitXorAssign for ImageFormatConstraintsFlagBitsFUCHSIA {
10926    #[inline]
10927    fn bitxor_assign(&mut self, rhs: Self) {
10928        self.0 ^= rhs.0;
10929    }
10930}
10931impl core::ops::Not for ImageFormatConstraintsFlagBitsFUCHSIA {
10932    type Output = Self;
10933    #[inline]
10934    fn not(self) -> Self {
10935        Self(!self.0)
10936    }
10937}
10938impl core::fmt::Debug for ImageFormatConstraintsFlagBitsFUCHSIA {
10939    #[allow(unused_mut, unused_variables)]
10940    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10941        let mut first = true;
10942        let mut remaining = self.0;
10943        if remaining != 0u32 {
10944            if !first {
10945                f.write_str(" | ")?;
10946            }
10947            write!(f, "{:#x}", remaining)?;
10948        } else if first {
10949            f.write_str("(empty)")?;
10950        }
10951        Ok(())
10952    }
10953}
10954///[`VkImageUsageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageUsageFlagBits.html)
10955#[repr(transparent)]
10956#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10957#[doc(alias = "VkImageUsageFlagBits")]
10958pub struct ImageUsageFlagBits(u32);
10959impl ImageUsageFlagBits {
10960    #[inline]
10961    pub const fn empty() -> Self {
10962        Self(0u32)
10963    }
10964    #[inline]
10965    pub const fn from_raw(value: u32) -> Self {
10966        Self(value)
10967    }
10968    #[inline]
10969    pub const fn as_raw(self) -> u32 {
10970        self.0
10971    }
10972    #[inline]
10973    pub const fn is_empty(self) -> bool {
10974        self.0 == 0u32
10975    }
10976    #[inline]
10977    pub const fn contains(self, other: Self) -> bool {
10978        (self.0 & other.0) == other.0
10979    }
10980    #[inline]
10981    pub const fn all() -> Self {
10982        Self(251461631u32)
10983    }
10984    ///Bit 0.
10985    pub const TRANSFER_SRC: Self = Self(1u32);
10986    ///Bit 1.
10987    pub const TRANSFER_DST: Self = Self(2u32);
10988    ///Bit 2.
10989    pub const SAMPLED: Self = Self(4u32);
10990    ///Bit 3.
10991    pub const STORAGE: Self = Self(8u32);
10992    ///Bit 4.
10993    pub const COLOR_ATTACHMENT: Self = Self(16u32);
10994    ///Bit 5.
10995    pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(32u32);
10996    ///Bit 6.
10997    pub const TRANSIENT_ATTACHMENT: Self = Self(64u32);
10998    ///Bit 7.
10999    pub const INPUT_ATTACHMENT: Self = Self(128u32);
11000    ///Bit 22.
11001    pub const HOST_TRANSFER: Self = Self(4194304u32);
11002    ///Bit 10.
11003    pub const VIDEO_DECODE_DST: Self = Self(1024u32);
11004    ///Bit 11.
11005    pub const VIDEO_DECODE_SRC: Self = Self(2048u32);
11006    ///Bit 12.
11007    pub const VIDEO_DECODE_DPB: Self = Self(4096u32);
11008    pub const SHADING_RATE_IMAGE: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT;
11009    ///Bit 9.
11010    pub const FRAGMENT_DENSITY_MAP: Self = Self(512u32);
11011    ///Bit 8.
11012    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(256u32);
11013    ///Bit 13.
11014    pub const VIDEO_ENCODE_DST: Self = Self(8192u32);
11015    ///Bit 14.
11016    pub const VIDEO_ENCODE_SRC: Self = Self(16384u32);
11017    ///Bit 15.
11018    pub const VIDEO_ENCODE_DPB: Self = Self(32768u32);
11019    ///Bit 19.
11020    pub const ATTACHMENT_FEEDBACK_LOOP: Self = Self(524288u32);
11021    ///Bit 18.
11022    pub const INVOCATION_MASK_BIT: Self = Self(262144u32);
11023    ///Bit 20.
11024    pub const SAMPLE_WEIGHT_BIT: Self = Self(1048576u32);
11025    ///Bit 21.
11026    pub const SAMPLE_BLOCK_MATCH_BIT: Self = Self(2097152u32);
11027    ///Bit 23.
11028    pub const TENSOR_ALIASING_BIT: Self = Self(8388608u32);
11029    ///Bit 27.
11030    pub const TILE_MEMORY_BIT: Self = Self(134217728u32);
11031    ///Bit 25.
11032    pub const VIDEO_ENCODE_QUANTIZATION_DELTA_MAP: Self = Self(33554432u32);
11033    ///Bit 26.
11034    pub const VIDEO_ENCODE_EMPHASIS_MAP: Self = Self(67108864u32);
11035}
11036impl core::ops::BitOr for ImageUsageFlagBits {
11037    type Output = Self;
11038    #[inline]
11039    fn bitor(self, rhs: Self) -> Self {
11040        Self(self.0 | rhs.0)
11041    }
11042}
11043impl core::ops::BitOrAssign for ImageUsageFlagBits {
11044    #[inline]
11045    fn bitor_assign(&mut self, rhs: Self) {
11046        self.0 |= rhs.0;
11047    }
11048}
11049impl core::ops::BitAnd for ImageUsageFlagBits {
11050    type Output = Self;
11051    #[inline]
11052    fn bitand(self, rhs: Self) -> Self {
11053        Self(self.0 & rhs.0)
11054    }
11055}
11056impl core::ops::BitAndAssign for ImageUsageFlagBits {
11057    #[inline]
11058    fn bitand_assign(&mut self, rhs: Self) {
11059        self.0 &= rhs.0;
11060    }
11061}
11062impl core::ops::BitXor for ImageUsageFlagBits {
11063    type Output = Self;
11064    #[inline]
11065    fn bitxor(self, rhs: Self) -> Self {
11066        Self(self.0 ^ rhs.0)
11067    }
11068}
11069impl core::ops::BitXorAssign for ImageUsageFlagBits {
11070    #[inline]
11071    fn bitxor_assign(&mut self, rhs: Self) {
11072        self.0 ^= rhs.0;
11073    }
11074}
11075impl core::ops::Not for ImageUsageFlagBits {
11076    type Output = Self;
11077    #[inline]
11078    fn not(self) -> Self {
11079        Self(!self.0)
11080    }
11081}
11082impl core::fmt::Debug for ImageUsageFlagBits {
11083    #[allow(unused_mut, unused_variables)]
11084    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11085        let mut first = true;
11086        let mut remaining = self.0;
11087        if remaining & Self::TRANSFER_SRC.0 != 0 {
11088            if !first {
11089                f.write_str(" | ")?;
11090            }
11091            f.write_str("TRANSFER_SRC")?;
11092            remaining &= !Self::TRANSFER_SRC.0;
11093            first = false;
11094        }
11095        if remaining & Self::TRANSFER_DST.0 != 0 {
11096            if !first {
11097                f.write_str(" | ")?;
11098            }
11099            f.write_str("TRANSFER_DST")?;
11100            remaining &= !Self::TRANSFER_DST.0;
11101            first = false;
11102        }
11103        if remaining & Self::SAMPLED.0 != 0 {
11104            if !first {
11105                f.write_str(" | ")?;
11106            }
11107            f.write_str("SAMPLED")?;
11108            remaining &= !Self::SAMPLED.0;
11109            first = false;
11110        }
11111        if remaining & Self::STORAGE.0 != 0 {
11112            if !first {
11113                f.write_str(" | ")?;
11114            }
11115            f.write_str("STORAGE")?;
11116            remaining &= !Self::STORAGE.0;
11117            first = false;
11118        }
11119        if remaining & Self::COLOR_ATTACHMENT.0 != 0 {
11120            if !first {
11121                f.write_str(" | ")?;
11122            }
11123            f.write_str("COLOR_ATTACHMENT")?;
11124            remaining &= !Self::COLOR_ATTACHMENT.0;
11125            first = false;
11126        }
11127        if remaining & Self::DEPTH_STENCIL_ATTACHMENT.0 != 0 {
11128            if !first {
11129                f.write_str(" | ")?;
11130            }
11131            f.write_str("DEPTH_STENCIL_ATTACHMENT")?;
11132            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT.0;
11133            first = false;
11134        }
11135        if remaining & Self::TRANSIENT_ATTACHMENT.0 != 0 {
11136            if !first {
11137                f.write_str(" | ")?;
11138            }
11139            f.write_str("TRANSIENT_ATTACHMENT")?;
11140            remaining &= !Self::TRANSIENT_ATTACHMENT.0;
11141            first = false;
11142        }
11143        if remaining & Self::INPUT_ATTACHMENT.0 != 0 {
11144            if !first {
11145                f.write_str(" | ")?;
11146            }
11147            f.write_str("INPUT_ATTACHMENT")?;
11148            remaining &= !Self::INPUT_ATTACHMENT.0;
11149            first = false;
11150        }
11151        if remaining & Self::HOST_TRANSFER.0 != 0 {
11152            if !first {
11153                f.write_str(" | ")?;
11154            }
11155            f.write_str("HOST_TRANSFER")?;
11156            remaining &= !Self::HOST_TRANSFER.0;
11157            first = false;
11158        }
11159        if remaining & Self::VIDEO_DECODE_DST.0 != 0 {
11160            if !first {
11161                f.write_str(" | ")?;
11162            }
11163            f.write_str("VIDEO_DECODE_DST")?;
11164            remaining &= !Self::VIDEO_DECODE_DST.0;
11165            first = false;
11166        }
11167        if remaining & Self::VIDEO_DECODE_SRC.0 != 0 {
11168            if !first {
11169                f.write_str(" | ")?;
11170            }
11171            f.write_str("VIDEO_DECODE_SRC")?;
11172            remaining &= !Self::VIDEO_DECODE_SRC.0;
11173            first = false;
11174        }
11175        if remaining & Self::VIDEO_DECODE_DPB.0 != 0 {
11176            if !first {
11177                f.write_str(" | ")?;
11178            }
11179            f.write_str("VIDEO_DECODE_DPB")?;
11180            remaining &= !Self::VIDEO_DECODE_DPB.0;
11181            first = false;
11182        }
11183        if remaining & Self::FRAGMENT_DENSITY_MAP.0 != 0 {
11184            if !first {
11185                f.write_str(" | ")?;
11186            }
11187            f.write_str("FRAGMENT_DENSITY_MAP")?;
11188            remaining &= !Self::FRAGMENT_DENSITY_MAP.0;
11189            first = false;
11190        }
11191        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
11192            if !first {
11193                f.write_str(" | ")?;
11194            }
11195            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT")?;
11196            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0;
11197            first = false;
11198        }
11199        if remaining & Self::VIDEO_ENCODE_DST.0 != 0 {
11200            if !first {
11201                f.write_str(" | ")?;
11202            }
11203            f.write_str("VIDEO_ENCODE_DST")?;
11204            remaining &= !Self::VIDEO_ENCODE_DST.0;
11205            first = false;
11206        }
11207        if remaining & Self::VIDEO_ENCODE_SRC.0 != 0 {
11208            if !first {
11209                f.write_str(" | ")?;
11210            }
11211            f.write_str("VIDEO_ENCODE_SRC")?;
11212            remaining &= !Self::VIDEO_ENCODE_SRC.0;
11213            first = false;
11214        }
11215        if remaining & Self::VIDEO_ENCODE_DPB.0 != 0 {
11216            if !first {
11217                f.write_str(" | ")?;
11218            }
11219            f.write_str("VIDEO_ENCODE_DPB")?;
11220            remaining &= !Self::VIDEO_ENCODE_DPB.0;
11221            first = false;
11222        }
11223        if remaining & Self::ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
11224            if !first {
11225                f.write_str(" | ")?;
11226            }
11227            f.write_str("ATTACHMENT_FEEDBACK_LOOP")?;
11228            remaining &= !Self::ATTACHMENT_FEEDBACK_LOOP.0;
11229            first = false;
11230        }
11231        if remaining & Self::INVOCATION_MASK_BIT.0 != 0 {
11232            if !first {
11233                f.write_str(" | ")?;
11234            }
11235            f.write_str("INVOCATION_MASK_BIT")?;
11236            remaining &= !Self::INVOCATION_MASK_BIT.0;
11237            first = false;
11238        }
11239        if remaining & Self::SAMPLE_WEIGHT_BIT.0 != 0 {
11240            if !first {
11241                f.write_str(" | ")?;
11242            }
11243            f.write_str("SAMPLE_WEIGHT_BIT")?;
11244            remaining &= !Self::SAMPLE_WEIGHT_BIT.0;
11245            first = false;
11246        }
11247        if remaining & Self::SAMPLE_BLOCK_MATCH_BIT.0 != 0 {
11248            if !first {
11249                f.write_str(" | ")?;
11250            }
11251            f.write_str("SAMPLE_BLOCK_MATCH_BIT")?;
11252            remaining &= !Self::SAMPLE_BLOCK_MATCH_BIT.0;
11253            first = false;
11254        }
11255        if remaining & Self::TENSOR_ALIASING_BIT.0 != 0 {
11256            if !first {
11257                f.write_str(" | ")?;
11258            }
11259            f.write_str("TENSOR_ALIASING_BIT")?;
11260            remaining &= !Self::TENSOR_ALIASING_BIT.0;
11261            first = false;
11262        }
11263        if remaining & Self::TILE_MEMORY_BIT.0 != 0 {
11264            if !first {
11265                f.write_str(" | ")?;
11266            }
11267            f.write_str("TILE_MEMORY_BIT")?;
11268            remaining &= !Self::TILE_MEMORY_BIT.0;
11269            first = false;
11270        }
11271        if remaining & Self::VIDEO_ENCODE_QUANTIZATION_DELTA_MAP.0 != 0 {
11272            if !first {
11273                f.write_str(" | ")?;
11274            }
11275            f.write_str("VIDEO_ENCODE_QUANTIZATION_DELTA_MAP")?;
11276            remaining &= !Self::VIDEO_ENCODE_QUANTIZATION_DELTA_MAP.0;
11277            first = false;
11278        }
11279        if remaining & Self::VIDEO_ENCODE_EMPHASIS_MAP.0 != 0 {
11280            if !first {
11281                f.write_str(" | ")?;
11282            }
11283            f.write_str("VIDEO_ENCODE_EMPHASIS_MAP")?;
11284            remaining &= !Self::VIDEO_ENCODE_EMPHASIS_MAP.0;
11285            first = false;
11286        }
11287        if remaining != 0u32 {
11288            if !first {
11289                f.write_str(" | ")?;
11290            }
11291            write!(f, "{:#x}", remaining)?;
11292        } else if first {
11293            f.write_str("(empty)")?;
11294        }
11295        Ok(())
11296    }
11297}
11298///[`VkImageViewCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCreateFlagBits.html)
11299#[repr(transparent)]
11300#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
11301#[doc(alias = "VkImageViewCreateFlagBits")]
11302pub struct ImageViewCreateFlagBits(u32);
11303impl ImageViewCreateFlagBits {
11304    #[inline]
11305    pub const fn empty() -> Self {
11306        Self(0u32)
11307    }
11308    #[inline]
11309    pub const fn from_raw(value: u32) -> Self {
11310        Self(value)
11311    }
11312    #[inline]
11313    pub const fn as_raw(self) -> u32 {
11314        self.0
11315    }
11316    #[inline]
11317    pub const fn is_empty(self) -> bool {
11318        self.0 == 0u32
11319    }
11320    #[inline]
11321    pub const fn contains(self, other: Self) -> bool {
11322        (self.0 & other.0) == other.0
11323    }
11324    #[inline]
11325    pub const fn all() -> Self {
11326        Self(7u32)
11327    }
11328    ///Bit 0.
11329    pub const FRAGMENT_DENSITY_MAP_DYNAMIC: Self = Self(1u32);
11330    ///Bit 2.
11331    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self(4u32);
11332    ///Bit 1.
11333    pub const FRAGMENT_DENSITY_MAP_DEFERRED: Self = Self(2u32);
11334}
11335impl core::ops::BitOr for ImageViewCreateFlagBits {
11336    type Output = Self;
11337    #[inline]
11338    fn bitor(self, rhs: Self) -> Self {
11339        Self(self.0 | rhs.0)
11340    }
11341}
11342impl core::ops::BitOrAssign for ImageViewCreateFlagBits {
11343    #[inline]
11344    fn bitor_assign(&mut self, rhs: Self) {
11345        self.0 |= rhs.0;
11346    }
11347}
11348impl core::ops::BitAnd for ImageViewCreateFlagBits {
11349    type Output = Self;
11350    #[inline]
11351    fn bitand(self, rhs: Self) -> Self {
11352        Self(self.0 & rhs.0)
11353    }
11354}
11355impl core::ops::BitAndAssign for ImageViewCreateFlagBits {
11356    #[inline]
11357    fn bitand_assign(&mut self, rhs: Self) {
11358        self.0 &= rhs.0;
11359    }
11360}
11361impl core::ops::BitXor for ImageViewCreateFlagBits {
11362    type Output = Self;
11363    #[inline]
11364    fn bitxor(self, rhs: Self) -> Self {
11365        Self(self.0 ^ rhs.0)
11366    }
11367}
11368impl core::ops::BitXorAssign for ImageViewCreateFlagBits {
11369    #[inline]
11370    fn bitxor_assign(&mut self, rhs: Self) {
11371        self.0 ^= rhs.0;
11372    }
11373}
11374impl core::ops::Not for ImageViewCreateFlagBits {
11375    type Output = Self;
11376    #[inline]
11377    fn not(self) -> Self {
11378        Self(!self.0)
11379    }
11380}
11381impl core::fmt::Debug for ImageViewCreateFlagBits {
11382    #[allow(unused_mut, unused_variables)]
11383    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11384        let mut first = true;
11385        let mut remaining = self.0;
11386        if remaining & Self::FRAGMENT_DENSITY_MAP_DYNAMIC.0 != 0 {
11387            if !first {
11388                f.write_str(" | ")?;
11389            }
11390            f.write_str("FRAGMENT_DENSITY_MAP_DYNAMIC")?;
11391            remaining &= !Self::FRAGMENT_DENSITY_MAP_DYNAMIC.0;
11392            first = false;
11393        }
11394        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0 != 0 {
11395            if !first {
11396                f.write_str(" | ")?;
11397            }
11398            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY")?;
11399            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0;
11400            first = false;
11401        }
11402        if remaining & Self::FRAGMENT_DENSITY_MAP_DEFERRED.0 != 0 {
11403            if !first {
11404                f.write_str(" | ")?;
11405            }
11406            f.write_str("FRAGMENT_DENSITY_MAP_DEFERRED")?;
11407            remaining &= !Self::FRAGMENT_DENSITY_MAP_DEFERRED.0;
11408            first = false;
11409        }
11410        if remaining != 0u32 {
11411            if !first {
11412                f.write_str(" | ")?;
11413            }
11414            write!(f, "{:#x}", remaining)?;
11415        } else if first {
11416            f.write_str("(empty)")?;
11417        }
11418        Ok(())
11419    }
11420}
11421///[`VkIndirectCommandsInputModeFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsInputModeFlagBitsEXT.html)
11422#[repr(transparent)]
11423#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
11424#[doc(alias = "VkIndirectCommandsInputModeFlagBitsEXT")]
11425pub struct IndirectCommandsInputModeFlagBitsEXT(u32);
11426impl IndirectCommandsInputModeFlagBitsEXT {
11427    #[inline]
11428    pub const fn empty() -> Self {
11429        Self(0u32)
11430    }
11431    #[inline]
11432    pub const fn from_raw(value: u32) -> Self {
11433        Self(value)
11434    }
11435    #[inline]
11436    pub const fn as_raw(self) -> u32 {
11437        self.0
11438    }
11439    #[inline]
11440    pub const fn is_empty(self) -> bool {
11441        self.0 == 0u32
11442    }
11443    #[inline]
11444    pub const fn contains(self, other: Self) -> bool {
11445        (self.0 & other.0) == other.0
11446    }
11447    #[inline]
11448    pub const fn all() -> Self {
11449        Self(3u32)
11450    }
11451    ///Bit 0.
11452    pub const VULKAN_INDEX_BUFFER: Self = Self(1u32);
11453    ///Bit 1.
11454    pub const DXGI_INDEX_BUFFER: Self = Self(2u32);
11455}
11456impl core::ops::BitOr for IndirectCommandsInputModeFlagBitsEXT {
11457    type Output = Self;
11458    #[inline]
11459    fn bitor(self, rhs: Self) -> Self {
11460        Self(self.0 | rhs.0)
11461    }
11462}
11463impl core::ops::BitOrAssign for IndirectCommandsInputModeFlagBitsEXT {
11464    #[inline]
11465    fn bitor_assign(&mut self, rhs: Self) {
11466        self.0 |= rhs.0;
11467    }
11468}
11469impl core::ops::BitAnd for IndirectCommandsInputModeFlagBitsEXT {
11470    type Output = Self;
11471    #[inline]
11472    fn bitand(self, rhs: Self) -> Self {
11473        Self(self.0 & rhs.0)
11474    }
11475}
11476impl core::ops::BitAndAssign for IndirectCommandsInputModeFlagBitsEXT {
11477    #[inline]
11478    fn bitand_assign(&mut self, rhs: Self) {
11479        self.0 &= rhs.0;
11480    }
11481}
11482impl core::ops::BitXor for IndirectCommandsInputModeFlagBitsEXT {
11483    type Output = Self;
11484    #[inline]
11485    fn bitxor(self, rhs: Self) -> Self {
11486        Self(self.0 ^ rhs.0)
11487    }
11488}
11489impl core::ops::BitXorAssign for IndirectCommandsInputModeFlagBitsEXT {
11490    #[inline]
11491    fn bitxor_assign(&mut self, rhs: Self) {
11492        self.0 ^= rhs.0;
11493    }
11494}
11495impl core::ops::Not for IndirectCommandsInputModeFlagBitsEXT {
11496    type Output = Self;
11497    #[inline]
11498    fn not(self) -> Self {
11499        Self(!self.0)
11500    }
11501}
11502impl core::fmt::Debug for IndirectCommandsInputModeFlagBitsEXT {
11503    #[allow(unused_mut, unused_variables)]
11504    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11505        let mut first = true;
11506        let mut remaining = self.0;
11507        if remaining & Self::VULKAN_INDEX_BUFFER.0 != 0 {
11508            if !first {
11509                f.write_str(" | ")?;
11510            }
11511            f.write_str("VULKAN_INDEX_BUFFER")?;
11512            remaining &= !Self::VULKAN_INDEX_BUFFER.0;
11513            first = false;
11514        }
11515        if remaining & Self::DXGI_INDEX_BUFFER.0 != 0 {
11516            if !first {
11517                f.write_str(" | ")?;
11518            }
11519            f.write_str("DXGI_INDEX_BUFFER")?;
11520            remaining &= !Self::DXGI_INDEX_BUFFER.0;
11521            first = false;
11522        }
11523        if remaining != 0u32 {
11524            if !first {
11525                f.write_str(" | ")?;
11526            }
11527            write!(f, "{:#x}", remaining)?;
11528        } else if first {
11529            f.write_str("(empty)")?;
11530        }
11531        Ok(())
11532    }
11533}
11534///[`VkIndirectCommandsLayoutUsageFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagBitsEXT.html)
11535#[repr(transparent)]
11536#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
11537#[doc(alias = "VkIndirectCommandsLayoutUsageFlagBitsEXT")]
11538pub struct IndirectCommandsLayoutUsageFlagBitsEXT(u32);
11539impl IndirectCommandsLayoutUsageFlagBitsEXT {
11540    #[inline]
11541    pub const fn empty() -> Self {
11542        Self(0u32)
11543    }
11544    #[inline]
11545    pub const fn from_raw(value: u32) -> Self {
11546        Self(value)
11547    }
11548    #[inline]
11549    pub const fn as_raw(self) -> u32 {
11550        self.0
11551    }
11552    #[inline]
11553    pub const fn is_empty(self) -> bool {
11554        self.0 == 0u32
11555    }
11556    #[inline]
11557    pub const fn contains(self, other: Self) -> bool {
11558        (self.0 & other.0) == other.0
11559    }
11560    #[inline]
11561    pub const fn all() -> Self {
11562        Self(3u32)
11563    }
11564    ///Bit 0.
11565    pub const EXPLICIT_PREPROCESS: Self = Self(1u32);
11566    ///Bit 1.
11567    pub const UNORDERED_SEQUENCES: Self = Self(2u32);
11568}
11569impl core::ops::BitOr for IndirectCommandsLayoutUsageFlagBitsEXT {
11570    type Output = Self;
11571    #[inline]
11572    fn bitor(self, rhs: Self) -> Self {
11573        Self(self.0 | rhs.0)
11574    }
11575}
11576impl core::ops::BitOrAssign for IndirectCommandsLayoutUsageFlagBitsEXT {
11577    #[inline]
11578    fn bitor_assign(&mut self, rhs: Self) {
11579        self.0 |= rhs.0;
11580    }
11581}
11582impl core::ops::BitAnd for IndirectCommandsLayoutUsageFlagBitsEXT {
11583    type Output = Self;
11584    #[inline]
11585    fn bitand(self, rhs: Self) -> Self {
11586        Self(self.0 & rhs.0)
11587    }
11588}
11589impl core::ops::BitAndAssign for IndirectCommandsLayoutUsageFlagBitsEXT {
11590    #[inline]
11591    fn bitand_assign(&mut self, rhs: Self) {
11592        self.0 &= rhs.0;
11593    }
11594}
11595impl core::ops::BitXor for IndirectCommandsLayoutUsageFlagBitsEXT {
11596    type Output = Self;
11597    #[inline]
11598    fn bitxor(self, rhs: Self) -> Self {
11599        Self(self.0 ^ rhs.0)
11600    }
11601}
11602impl core::ops::BitXorAssign for IndirectCommandsLayoutUsageFlagBitsEXT {
11603    #[inline]
11604    fn bitxor_assign(&mut self, rhs: Self) {
11605        self.0 ^= rhs.0;
11606    }
11607}
11608impl core::ops::Not for IndirectCommandsLayoutUsageFlagBitsEXT {
11609    type Output = Self;
11610    #[inline]
11611    fn not(self) -> Self {
11612        Self(!self.0)
11613    }
11614}
11615impl core::fmt::Debug for IndirectCommandsLayoutUsageFlagBitsEXT {
11616    #[allow(unused_mut, unused_variables)]
11617    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11618        let mut first = true;
11619        let mut remaining = self.0;
11620        if remaining & Self::EXPLICIT_PREPROCESS.0 != 0 {
11621            if !first {
11622                f.write_str(" | ")?;
11623            }
11624            f.write_str("EXPLICIT_PREPROCESS")?;
11625            remaining &= !Self::EXPLICIT_PREPROCESS.0;
11626            first = false;
11627        }
11628        if remaining & Self::UNORDERED_SEQUENCES.0 != 0 {
11629            if !first {
11630                f.write_str(" | ")?;
11631            }
11632            f.write_str("UNORDERED_SEQUENCES")?;
11633            remaining &= !Self::UNORDERED_SEQUENCES.0;
11634            first = false;
11635        }
11636        if remaining != 0u32 {
11637            if !first {
11638                f.write_str(" | ")?;
11639            }
11640            write!(f, "{:#x}", remaining)?;
11641        } else if first {
11642            f.write_str("(empty)")?;
11643        }
11644        Ok(())
11645    }
11646}
11647///[`VkIndirectCommandsLayoutUsageFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html)
11648#[repr(transparent)]
11649#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
11650#[doc(alias = "VkIndirectCommandsLayoutUsageFlagBitsNV")]
11651pub struct IndirectCommandsLayoutUsageFlagBitsNV(u32);
11652impl IndirectCommandsLayoutUsageFlagBitsNV {
11653    #[inline]
11654    pub const fn empty() -> Self {
11655        Self(0u32)
11656    }
11657    #[inline]
11658    pub const fn from_raw(value: u32) -> Self {
11659        Self(value)
11660    }
11661    #[inline]
11662    pub const fn as_raw(self) -> u32 {
11663        self.0
11664    }
11665    #[inline]
11666    pub const fn is_empty(self) -> bool {
11667        self.0 == 0u32
11668    }
11669    #[inline]
11670    pub const fn contains(self, other: Self) -> bool {
11671        (self.0 & other.0) == other.0
11672    }
11673    #[inline]
11674    pub const fn all() -> Self {
11675        Self(7u32)
11676    }
11677    ///Bit 0.
11678    pub const EXPLICIT_PREPROCESS: Self = Self(1u32);
11679    ///Bit 1.
11680    pub const INDEXED_SEQUENCES: Self = Self(2u32);
11681    ///Bit 2.
11682    pub const UNORDERED_SEQUENCES: Self = Self(4u32);
11683}
11684impl core::ops::BitOr for IndirectCommandsLayoutUsageFlagBitsNV {
11685    type Output = Self;
11686    #[inline]
11687    fn bitor(self, rhs: Self) -> Self {
11688        Self(self.0 | rhs.0)
11689    }
11690}
11691impl core::ops::BitOrAssign for IndirectCommandsLayoutUsageFlagBitsNV {
11692    #[inline]
11693    fn bitor_assign(&mut self, rhs: Self) {
11694        self.0 |= rhs.0;
11695    }
11696}
11697impl core::ops::BitAnd for IndirectCommandsLayoutUsageFlagBitsNV {
11698    type Output = Self;
11699    #[inline]
11700    fn bitand(self, rhs: Self) -> Self {
11701        Self(self.0 & rhs.0)
11702    }
11703}
11704impl core::ops::BitAndAssign for IndirectCommandsLayoutUsageFlagBitsNV {
11705    #[inline]
11706    fn bitand_assign(&mut self, rhs: Self) {
11707        self.0 &= rhs.0;
11708    }
11709}
11710impl core::ops::BitXor for IndirectCommandsLayoutUsageFlagBitsNV {
11711    type Output = Self;
11712    #[inline]
11713    fn bitxor(self, rhs: Self) -> Self {
11714        Self(self.0 ^ rhs.0)
11715    }
11716}
11717impl core::ops::BitXorAssign for IndirectCommandsLayoutUsageFlagBitsNV {
11718    #[inline]
11719    fn bitxor_assign(&mut self, rhs: Self) {
11720        self.0 ^= rhs.0;
11721    }
11722}
11723impl core::ops::Not for IndirectCommandsLayoutUsageFlagBitsNV {
11724    type Output = Self;
11725    #[inline]
11726    fn not(self) -> Self {
11727        Self(!self.0)
11728    }
11729}
11730impl core::fmt::Debug for IndirectCommandsLayoutUsageFlagBitsNV {
11731    #[allow(unused_mut, unused_variables)]
11732    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11733        let mut first = true;
11734        let mut remaining = self.0;
11735        if remaining & Self::EXPLICIT_PREPROCESS.0 != 0 {
11736            if !first {
11737                f.write_str(" | ")?;
11738            }
11739            f.write_str("EXPLICIT_PREPROCESS")?;
11740            remaining &= !Self::EXPLICIT_PREPROCESS.0;
11741            first = false;
11742        }
11743        if remaining & Self::INDEXED_SEQUENCES.0 != 0 {
11744            if !first {
11745                f.write_str(" | ")?;
11746            }
11747            f.write_str("INDEXED_SEQUENCES")?;
11748            remaining &= !Self::INDEXED_SEQUENCES.0;
11749            first = false;
11750        }
11751        if remaining & Self::UNORDERED_SEQUENCES.0 != 0 {
11752            if !first {
11753                f.write_str(" | ")?;
11754            }
11755            f.write_str("UNORDERED_SEQUENCES")?;
11756            remaining &= !Self::UNORDERED_SEQUENCES.0;
11757            first = false;
11758        }
11759        if remaining != 0u32 {
11760            if !first {
11761                f.write_str(" | ")?;
11762            }
11763            write!(f, "{:#x}", remaining)?;
11764        } else if first {
11765            f.write_str("(empty)")?;
11766        }
11767        Ok(())
11768    }
11769}
11770///[`VkIndirectStateFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectStateFlagBitsNV.html)
11771#[repr(transparent)]
11772#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
11773#[doc(alias = "VkIndirectStateFlagBitsNV")]
11774pub struct IndirectStateFlagBitsNV(u32);
11775impl IndirectStateFlagBitsNV {
11776    #[inline]
11777    pub const fn empty() -> Self {
11778        Self(0u32)
11779    }
11780    #[inline]
11781    pub const fn from_raw(value: u32) -> Self {
11782        Self(value)
11783    }
11784    #[inline]
11785    pub const fn as_raw(self) -> u32 {
11786        self.0
11787    }
11788    #[inline]
11789    pub const fn is_empty(self) -> bool {
11790        self.0 == 0u32
11791    }
11792    #[inline]
11793    pub const fn contains(self, other: Self) -> bool {
11794        (self.0 & other.0) == other.0
11795    }
11796    #[inline]
11797    pub const fn all() -> Self {
11798        Self(1u32)
11799    }
11800    ///Bit 0.
11801    pub const FLAG_FRONTFACE: Self = Self(1u32);
11802}
11803impl core::ops::BitOr for IndirectStateFlagBitsNV {
11804    type Output = Self;
11805    #[inline]
11806    fn bitor(self, rhs: Self) -> Self {
11807        Self(self.0 | rhs.0)
11808    }
11809}
11810impl core::ops::BitOrAssign for IndirectStateFlagBitsNV {
11811    #[inline]
11812    fn bitor_assign(&mut self, rhs: Self) {
11813        self.0 |= rhs.0;
11814    }
11815}
11816impl core::ops::BitAnd for IndirectStateFlagBitsNV {
11817    type Output = Self;
11818    #[inline]
11819    fn bitand(self, rhs: Self) -> Self {
11820        Self(self.0 & rhs.0)
11821    }
11822}
11823impl core::ops::BitAndAssign for IndirectStateFlagBitsNV {
11824    #[inline]
11825    fn bitand_assign(&mut self, rhs: Self) {
11826        self.0 &= rhs.0;
11827    }
11828}
11829impl core::ops::BitXor for IndirectStateFlagBitsNV {
11830    type Output = Self;
11831    #[inline]
11832    fn bitxor(self, rhs: Self) -> Self {
11833        Self(self.0 ^ rhs.0)
11834    }
11835}
11836impl core::ops::BitXorAssign for IndirectStateFlagBitsNV {
11837    #[inline]
11838    fn bitxor_assign(&mut self, rhs: Self) {
11839        self.0 ^= rhs.0;
11840    }
11841}
11842impl core::ops::Not for IndirectStateFlagBitsNV {
11843    type Output = Self;
11844    #[inline]
11845    fn not(self) -> Self {
11846        Self(!self.0)
11847    }
11848}
11849impl core::fmt::Debug for IndirectStateFlagBitsNV {
11850    #[allow(unused_mut, unused_variables)]
11851    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11852        let mut first = true;
11853        let mut remaining = self.0;
11854        if remaining & Self::FLAG_FRONTFACE.0 != 0 {
11855            if !first {
11856                f.write_str(" | ")?;
11857            }
11858            f.write_str("FLAG_FRONTFACE")?;
11859            remaining &= !Self::FLAG_FRONTFACE.0;
11860            first = false;
11861        }
11862        if remaining != 0u32 {
11863            if !first {
11864                f.write_str(" | ")?;
11865            }
11866            write!(f, "{:#x}", remaining)?;
11867        } else if first {
11868            f.write_str("(empty)")?;
11869        }
11870        Ok(())
11871    }
11872}
11873///[`VkInstanceCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateFlagBits.html)
11874#[repr(transparent)]
11875#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
11876#[doc(alias = "VkInstanceCreateFlagBits")]
11877pub struct InstanceCreateFlagBits(u32);
11878impl InstanceCreateFlagBits {
11879    #[inline]
11880    pub const fn empty() -> Self {
11881        Self(0u32)
11882    }
11883    #[inline]
11884    pub const fn from_raw(value: u32) -> Self {
11885        Self(value)
11886    }
11887    #[inline]
11888    pub const fn as_raw(self) -> u32 {
11889        self.0
11890    }
11891    #[inline]
11892    pub const fn is_empty(self) -> bool {
11893        self.0 == 0u32
11894    }
11895    #[inline]
11896    pub const fn contains(self, other: Self) -> bool {
11897        (self.0 & other.0) == other.0
11898    }
11899    #[inline]
11900    pub const fn all() -> Self {
11901        Self(1u32)
11902    }
11903    ///Bit 0.
11904    pub const ENUMERATE_PORTABILITY: Self = Self(1u32);
11905}
11906impl core::ops::BitOr for InstanceCreateFlagBits {
11907    type Output = Self;
11908    #[inline]
11909    fn bitor(self, rhs: Self) -> Self {
11910        Self(self.0 | rhs.0)
11911    }
11912}
11913impl core::ops::BitOrAssign for InstanceCreateFlagBits {
11914    #[inline]
11915    fn bitor_assign(&mut self, rhs: Self) {
11916        self.0 |= rhs.0;
11917    }
11918}
11919impl core::ops::BitAnd for InstanceCreateFlagBits {
11920    type Output = Self;
11921    #[inline]
11922    fn bitand(self, rhs: Self) -> Self {
11923        Self(self.0 & rhs.0)
11924    }
11925}
11926impl core::ops::BitAndAssign for InstanceCreateFlagBits {
11927    #[inline]
11928    fn bitand_assign(&mut self, rhs: Self) {
11929        self.0 &= rhs.0;
11930    }
11931}
11932impl core::ops::BitXor for InstanceCreateFlagBits {
11933    type Output = Self;
11934    #[inline]
11935    fn bitxor(self, rhs: Self) -> Self {
11936        Self(self.0 ^ rhs.0)
11937    }
11938}
11939impl core::ops::BitXorAssign for InstanceCreateFlagBits {
11940    #[inline]
11941    fn bitxor_assign(&mut self, rhs: Self) {
11942        self.0 ^= rhs.0;
11943    }
11944}
11945impl core::ops::Not for InstanceCreateFlagBits {
11946    type Output = Self;
11947    #[inline]
11948    fn not(self) -> Self {
11949        Self(!self.0)
11950    }
11951}
11952impl core::fmt::Debug for InstanceCreateFlagBits {
11953    #[allow(unused_mut, unused_variables)]
11954    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11955        let mut first = true;
11956        let mut remaining = self.0;
11957        if remaining & Self::ENUMERATE_PORTABILITY.0 != 0 {
11958            if !first {
11959                f.write_str(" | ")?;
11960            }
11961            f.write_str("ENUMERATE_PORTABILITY")?;
11962            remaining &= !Self::ENUMERATE_PORTABILITY.0;
11963            first = false;
11964        }
11965        if remaining != 0u32 {
11966            if !first {
11967                f.write_str(" | ")?;
11968            }
11969            write!(f, "{:#x}", remaining)?;
11970        } else if first {
11971            f.write_str("(empty)")?;
11972        }
11973        Ok(())
11974    }
11975}
11976///[`VkMemoryAllocateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateFlagBits.html)
11977#[repr(transparent)]
11978#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
11979#[doc(alias = "VkMemoryAllocateFlagBits")]
11980pub struct MemoryAllocateFlagBits(u32);
11981impl MemoryAllocateFlagBits {
11982    #[inline]
11983    pub const fn empty() -> Self {
11984        Self(0u32)
11985    }
11986    #[inline]
11987    pub const fn from_raw(value: u32) -> Self {
11988        Self(value)
11989    }
11990    #[inline]
11991    pub const fn as_raw(self) -> u32 {
11992        self.0
11993    }
11994    #[inline]
11995    pub const fn is_empty(self) -> bool {
11996        self.0 == 0u32
11997    }
11998    #[inline]
11999    pub const fn contains(self, other: Self) -> bool {
12000        (self.0 & other.0) == other.0
12001    }
12002    #[inline]
12003    pub const fn all() -> Self {
12004        Self(15u32)
12005    }
12006    ///Bit 0.
12007    pub const DEVICE_MASK: Self = Self(1u32);
12008    ///Bit 1.
12009    pub const DEVICE_ADDRESS: Self = Self(2u32);
12010    ///Bit 2.
12011    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(4u32);
12012    ///Bit 3.
12013    pub const ZERO_INITIALIZE: Self = Self(8u32);
12014}
12015impl core::ops::BitOr for MemoryAllocateFlagBits {
12016    type Output = Self;
12017    #[inline]
12018    fn bitor(self, rhs: Self) -> Self {
12019        Self(self.0 | rhs.0)
12020    }
12021}
12022impl core::ops::BitOrAssign for MemoryAllocateFlagBits {
12023    #[inline]
12024    fn bitor_assign(&mut self, rhs: Self) {
12025        self.0 |= rhs.0;
12026    }
12027}
12028impl core::ops::BitAnd for MemoryAllocateFlagBits {
12029    type Output = Self;
12030    #[inline]
12031    fn bitand(self, rhs: Self) -> Self {
12032        Self(self.0 & rhs.0)
12033    }
12034}
12035impl core::ops::BitAndAssign for MemoryAllocateFlagBits {
12036    #[inline]
12037    fn bitand_assign(&mut self, rhs: Self) {
12038        self.0 &= rhs.0;
12039    }
12040}
12041impl core::ops::BitXor for MemoryAllocateFlagBits {
12042    type Output = Self;
12043    #[inline]
12044    fn bitxor(self, rhs: Self) -> Self {
12045        Self(self.0 ^ rhs.0)
12046    }
12047}
12048impl core::ops::BitXorAssign for MemoryAllocateFlagBits {
12049    #[inline]
12050    fn bitxor_assign(&mut self, rhs: Self) {
12051        self.0 ^= rhs.0;
12052    }
12053}
12054impl core::ops::Not for MemoryAllocateFlagBits {
12055    type Output = Self;
12056    #[inline]
12057    fn not(self) -> Self {
12058        Self(!self.0)
12059    }
12060}
12061impl core::fmt::Debug for MemoryAllocateFlagBits {
12062    #[allow(unused_mut, unused_variables)]
12063    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12064        let mut first = true;
12065        let mut remaining = self.0;
12066        if remaining & Self::DEVICE_MASK.0 != 0 {
12067            if !first {
12068                f.write_str(" | ")?;
12069            }
12070            f.write_str("DEVICE_MASK")?;
12071            remaining &= !Self::DEVICE_MASK.0;
12072            first = false;
12073        }
12074        if remaining & Self::DEVICE_ADDRESS.0 != 0 {
12075            if !first {
12076                f.write_str(" | ")?;
12077            }
12078            f.write_str("DEVICE_ADDRESS")?;
12079            remaining &= !Self::DEVICE_ADDRESS.0;
12080            first = false;
12081        }
12082        if remaining & Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0 != 0 {
12083            if !first {
12084                f.write_str(" | ")?;
12085            }
12086            f.write_str("DEVICE_ADDRESS_CAPTURE_REPLAY")?;
12087            remaining &= !Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0;
12088            first = false;
12089        }
12090        if remaining & Self::ZERO_INITIALIZE.0 != 0 {
12091            if !first {
12092                f.write_str(" | ")?;
12093            }
12094            f.write_str("ZERO_INITIALIZE")?;
12095            remaining &= !Self::ZERO_INITIALIZE.0;
12096            first = false;
12097        }
12098        if remaining != 0u32 {
12099            if !first {
12100                f.write_str(" | ")?;
12101            }
12102            write!(f, "{:#x}", remaining)?;
12103        } else if first {
12104            f.write_str("(empty)")?;
12105        }
12106        Ok(())
12107    }
12108}
12109///[`VkMemoryDecompressionMethodFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDecompressionMethodFlagBitsEXT.html)
12110#[repr(transparent)]
12111#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
12112#[doc(alias = "VkMemoryDecompressionMethodFlagBitsEXT")]
12113pub struct MemoryDecompressionMethodFlagBitsEXT(u64);
12114impl MemoryDecompressionMethodFlagBitsEXT {
12115    #[inline]
12116    pub const fn empty() -> Self {
12117        Self(0u64)
12118    }
12119    #[inline]
12120    pub const fn from_raw(value: u64) -> Self {
12121        Self(value)
12122    }
12123    #[inline]
12124    pub const fn as_raw(self) -> u64 {
12125        self.0
12126    }
12127    #[inline]
12128    pub const fn is_empty(self) -> bool {
12129        self.0 == 0u64
12130    }
12131    #[inline]
12132    pub const fn contains(self, other: Self) -> bool {
12133        (self.0 & other.0) == other.0
12134    }
12135    #[inline]
12136    pub const fn all() -> Self {
12137        Self(1u64)
12138    }
12139    ///Bit 0.
12140    pub const GDEFLATE_1_0: Self = Self(1u64);
12141}
12142impl core::ops::BitOr for MemoryDecompressionMethodFlagBitsEXT {
12143    type Output = Self;
12144    #[inline]
12145    fn bitor(self, rhs: Self) -> Self {
12146        Self(self.0 | rhs.0)
12147    }
12148}
12149impl core::ops::BitOrAssign for MemoryDecompressionMethodFlagBitsEXT {
12150    #[inline]
12151    fn bitor_assign(&mut self, rhs: Self) {
12152        self.0 |= rhs.0;
12153    }
12154}
12155impl core::ops::BitAnd for MemoryDecompressionMethodFlagBitsEXT {
12156    type Output = Self;
12157    #[inline]
12158    fn bitand(self, rhs: Self) -> Self {
12159        Self(self.0 & rhs.0)
12160    }
12161}
12162impl core::ops::BitAndAssign for MemoryDecompressionMethodFlagBitsEXT {
12163    #[inline]
12164    fn bitand_assign(&mut self, rhs: Self) {
12165        self.0 &= rhs.0;
12166    }
12167}
12168impl core::ops::BitXor for MemoryDecompressionMethodFlagBitsEXT {
12169    type Output = Self;
12170    #[inline]
12171    fn bitxor(self, rhs: Self) -> Self {
12172        Self(self.0 ^ rhs.0)
12173    }
12174}
12175impl core::ops::BitXorAssign for MemoryDecompressionMethodFlagBitsEXT {
12176    #[inline]
12177    fn bitxor_assign(&mut self, rhs: Self) {
12178        self.0 ^= rhs.0;
12179    }
12180}
12181impl core::ops::Not for MemoryDecompressionMethodFlagBitsEXT {
12182    type Output = Self;
12183    #[inline]
12184    fn not(self) -> Self {
12185        Self(!self.0)
12186    }
12187}
12188impl core::fmt::Debug for MemoryDecompressionMethodFlagBitsEXT {
12189    #[allow(unused_mut, unused_variables)]
12190    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12191        let mut first = true;
12192        let mut remaining = self.0;
12193        if remaining & Self::GDEFLATE_1_0.0 != 0 {
12194            if !first {
12195                f.write_str(" | ")?;
12196            }
12197            f.write_str("GDEFLATE_1_0")?;
12198            remaining &= !Self::GDEFLATE_1_0.0;
12199            first = false;
12200        }
12201        if remaining != 0u64 {
12202            if !first {
12203                f.write_str(" | ")?;
12204            }
12205            write!(f, "{:#x}", remaining)?;
12206        } else if first {
12207            f.write_str("(empty)")?;
12208        }
12209        Ok(())
12210    }
12211}
12212///[`VkMemoryHeapFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeapFlagBits.html)
12213#[repr(transparent)]
12214#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
12215#[doc(alias = "VkMemoryHeapFlagBits")]
12216pub struct MemoryHeapFlagBits(u32);
12217impl MemoryHeapFlagBits {
12218    #[inline]
12219    pub const fn empty() -> Self {
12220        Self(0u32)
12221    }
12222    #[inline]
12223    pub const fn from_raw(value: u32) -> Self {
12224        Self(value)
12225    }
12226    #[inline]
12227    pub const fn as_raw(self) -> u32 {
12228        self.0
12229    }
12230    #[inline]
12231    pub const fn is_empty(self) -> bool {
12232        self.0 == 0u32
12233    }
12234    #[inline]
12235    pub const fn contains(self, other: Self) -> bool {
12236        (self.0 & other.0) == other.0
12237    }
12238    #[inline]
12239    pub const fn all() -> Self {
12240        Self(15u32)
12241    }
12242    ///Bit 0.
12243    pub const DEVICE_LOCAL: Self = Self(1u32);
12244    ///Bit 1.
12245    pub const MULTI_INSTANCE: Self = Self(2u32);
12246    ///Bit 2.
12247    pub const SEU_SAFE: Self = Self(4u32);
12248    ///Bit 3.
12249    pub const TILE_MEMORY_BIT: Self = Self(8u32);
12250}
12251impl core::ops::BitOr for MemoryHeapFlagBits {
12252    type Output = Self;
12253    #[inline]
12254    fn bitor(self, rhs: Self) -> Self {
12255        Self(self.0 | rhs.0)
12256    }
12257}
12258impl core::ops::BitOrAssign for MemoryHeapFlagBits {
12259    #[inline]
12260    fn bitor_assign(&mut self, rhs: Self) {
12261        self.0 |= rhs.0;
12262    }
12263}
12264impl core::ops::BitAnd for MemoryHeapFlagBits {
12265    type Output = Self;
12266    #[inline]
12267    fn bitand(self, rhs: Self) -> Self {
12268        Self(self.0 & rhs.0)
12269    }
12270}
12271impl core::ops::BitAndAssign for MemoryHeapFlagBits {
12272    #[inline]
12273    fn bitand_assign(&mut self, rhs: Self) {
12274        self.0 &= rhs.0;
12275    }
12276}
12277impl core::ops::BitXor for MemoryHeapFlagBits {
12278    type Output = Self;
12279    #[inline]
12280    fn bitxor(self, rhs: Self) -> Self {
12281        Self(self.0 ^ rhs.0)
12282    }
12283}
12284impl core::ops::BitXorAssign for MemoryHeapFlagBits {
12285    #[inline]
12286    fn bitxor_assign(&mut self, rhs: Self) {
12287        self.0 ^= rhs.0;
12288    }
12289}
12290impl core::ops::Not for MemoryHeapFlagBits {
12291    type Output = Self;
12292    #[inline]
12293    fn not(self) -> Self {
12294        Self(!self.0)
12295    }
12296}
12297impl core::fmt::Debug for MemoryHeapFlagBits {
12298    #[allow(unused_mut, unused_variables)]
12299    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12300        let mut first = true;
12301        let mut remaining = self.0;
12302        if remaining & Self::DEVICE_LOCAL.0 != 0 {
12303            if !first {
12304                f.write_str(" | ")?;
12305            }
12306            f.write_str("DEVICE_LOCAL")?;
12307            remaining &= !Self::DEVICE_LOCAL.0;
12308            first = false;
12309        }
12310        if remaining & Self::MULTI_INSTANCE.0 != 0 {
12311            if !first {
12312                f.write_str(" | ")?;
12313            }
12314            f.write_str("MULTI_INSTANCE")?;
12315            remaining &= !Self::MULTI_INSTANCE.0;
12316            first = false;
12317        }
12318        if remaining & Self::SEU_SAFE.0 != 0 {
12319            if !first {
12320                f.write_str(" | ")?;
12321            }
12322            f.write_str("SEU_SAFE")?;
12323            remaining &= !Self::SEU_SAFE.0;
12324            first = false;
12325        }
12326        if remaining & Self::TILE_MEMORY_BIT.0 != 0 {
12327            if !first {
12328                f.write_str(" | ")?;
12329            }
12330            f.write_str("TILE_MEMORY_BIT")?;
12331            remaining &= !Self::TILE_MEMORY_BIT.0;
12332            first = false;
12333        }
12334        if remaining != 0u32 {
12335            if !first {
12336                f.write_str(" | ")?;
12337            }
12338            write!(f, "{:#x}", remaining)?;
12339        } else if first {
12340            f.write_str("(empty)")?;
12341        }
12342        Ok(())
12343    }
12344}
12345///[`VkMemoryMapFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapFlagBits.html)
12346#[repr(transparent)]
12347#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
12348#[doc(alias = "VkMemoryMapFlagBits")]
12349pub struct MemoryMapFlagBits(u32);
12350impl MemoryMapFlagBits {
12351    #[inline]
12352    pub const fn empty() -> Self {
12353        Self(0u32)
12354    }
12355    #[inline]
12356    pub const fn from_raw(value: u32) -> Self {
12357        Self(value)
12358    }
12359    #[inline]
12360    pub const fn as_raw(self) -> u32 {
12361        self.0
12362    }
12363    #[inline]
12364    pub const fn is_empty(self) -> bool {
12365        self.0 == 0u32
12366    }
12367    #[inline]
12368    pub const fn contains(self, other: Self) -> bool {
12369        (self.0 & other.0) == other.0
12370    }
12371    #[inline]
12372    pub const fn all() -> Self {
12373        Self(1u32)
12374    }
12375    ///Bit 0.
12376    pub const PLACED: Self = Self(1u32);
12377}
12378impl core::ops::BitOr for MemoryMapFlagBits {
12379    type Output = Self;
12380    #[inline]
12381    fn bitor(self, rhs: Self) -> Self {
12382        Self(self.0 | rhs.0)
12383    }
12384}
12385impl core::ops::BitOrAssign for MemoryMapFlagBits {
12386    #[inline]
12387    fn bitor_assign(&mut self, rhs: Self) {
12388        self.0 |= rhs.0;
12389    }
12390}
12391impl core::ops::BitAnd for MemoryMapFlagBits {
12392    type Output = Self;
12393    #[inline]
12394    fn bitand(self, rhs: Self) -> Self {
12395        Self(self.0 & rhs.0)
12396    }
12397}
12398impl core::ops::BitAndAssign for MemoryMapFlagBits {
12399    #[inline]
12400    fn bitand_assign(&mut self, rhs: Self) {
12401        self.0 &= rhs.0;
12402    }
12403}
12404impl core::ops::BitXor for MemoryMapFlagBits {
12405    type Output = Self;
12406    #[inline]
12407    fn bitxor(self, rhs: Self) -> Self {
12408        Self(self.0 ^ rhs.0)
12409    }
12410}
12411impl core::ops::BitXorAssign for MemoryMapFlagBits {
12412    #[inline]
12413    fn bitxor_assign(&mut self, rhs: Self) {
12414        self.0 ^= rhs.0;
12415    }
12416}
12417impl core::ops::Not for MemoryMapFlagBits {
12418    type Output = Self;
12419    #[inline]
12420    fn not(self) -> Self {
12421        Self(!self.0)
12422    }
12423}
12424impl core::fmt::Debug for MemoryMapFlagBits {
12425    #[allow(unused_mut, unused_variables)]
12426    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12427        let mut first = true;
12428        let mut remaining = self.0;
12429        if remaining & Self::PLACED.0 != 0 {
12430            if !first {
12431                f.write_str(" | ")?;
12432            }
12433            f.write_str("PLACED")?;
12434            remaining &= !Self::PLACED.0;
12435            first = false;
12436        }
12437        if remaining != 0u32 {
12438            if !first {
12439                f.write_str(" | ")?;
12440            }
12441            write!(f, "{:#x}", remaining)?;
12442        } else if first {
12443            f.write_str("(empty)")?;
12444        }
12445        Ok(())
12446    }
12447}
12448///[`VkMemoryPropertyFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPropertyFlagBits.html)
12449#[repr(transparent)]
12450#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
12451#[doc(alias = "VkMemoryPropertyFlagBits")]
12452pub struct MemoryPropertyFlagBits(u32);
12453impl MemoryPropertyFlagBits {
12454    #[inline]
12455    pub const fn empty() -> Self {
12456        Self(0u32)
12457    }
12458    #[inline]
12459    pub const fn from_raw(value: u32) -> Self {
12460        Self(value)
12461    }
12462    #[inline]
12463    pub const fn as_raw(self) -> u32 {
12464        self.0
12465    }
12466    #[inline]
12467    pub const fn is_empty(self) -> bool {
12468        self.0 == 0u32
12469    }
12470    #[inline]
12471    pub const fn contains(self, other: Self) -> bool {
12472        (self.0 & other.0) == other.0
12473    }
12474    #[inline]
12475    pub const fn all() -> Self {
12476        Self(511u32)
12477    }
12478    ///Bit 0.
12479    pub const DEVICE_LOCAL: Self = Self(1u32);
12480    ///Bit 1.
12481    pub const HOST_VISIBLE: Self = Self(2u32);
12482    ///Bit 2.
12483    pub const HOST_COHERENT: Self = Self(4u32);
12484    ///Bit 3.
12485    pub const HOST_CACHED: Self = Self(8u32);
12486    ///Bit 4.
12487    pub const LAZILY_ALLOCATED: Self = Self(16u32);
12488    ///Bit 5.
12489    pub const PROTECTED: Self = Self(32u32);
12490    ///Bit 6.
12491    pub const DEVICE_COHERENT: Self = Self(64u32);
12492    ///Bit 7.
12493    pub const DEVICE_UNCACHED: Self = Self(128u32);
12494    ///Bit 8.
12495    pub const RDMA_CAPABLE: Self = Self(256u32);
12496}
12497impl core::ops::BitOr for MemoryPropertyFlagBits {
12498    type Output = Self;
12499    #[inline]
12500    fn bitor(self, rhs: Self) -> Self {
12501        Self(self.0 | rhs.0)
12502    }
12503}
12504impl core::ops::BitOrAssign for MemoryPropertyFlagBits {
12505    #[inline]
12506    fn bitor_assign(&mut self, rhs: Self) {
12507        self.0 |= rhs.0;
12508    }
12509}
12510impl core::ops::BitAnd for MemoryPropertyFlagBits {
12511    type Output = Self;
12512    #[inline]
12513    fn bitand(self, rhs: Self) -> Self {
12514        Self(self.0 & rhs.0)
12515    }
12516}
12517impl core::ops::BitAndAssign for MemoryPropertyFlagBits {
12518    #[inline]
12519    fn bitand_assign(&mut self, rhs: Self) {
12520        self.0 &= rhs.0;
12521    }
12522}
12523impl core::ops::BitXor for MemoryPropertyFlagBits {
12524    type Output = Self;
12525    #[inline]
12526    fn bitxor(self, rhs: Self) -> Self {
12527        Self(self.0 ^ rhs.0)
12528    }
12529}
12530impl core::ops::BitXorAssign for MemoryPropertyFlagBits {
12531    #[inline]
12532    fn bitxor_assign(&mut self, rhs: Self) {
12533        self.0 ^= rhs.0;
12534    }
12535}
12536impl core::ops::Not for MemoryPropertyFlagBits {
12537    type Output = Self;
12538    #[inline]
12539    fn not(self) -> Self {
12540        Self(!self.0)
12541    }
12542}
12543impl core::fmt::Debug for MemoryPropertyFlagBits {
12544    #[allow(unused_mut, unused_variables)]
12545    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12546        let mut first = true;
12547        let mut remaining = self.0;
12548        if remaining & Self::DEVICE_LOCAL.0 != 0 {
12549            if !first {
12550                f.write_str(" | ")?;
12551            }
12552            f.write_str("DEVICE_LOCAL")?;
12553            remaining &= !Self::DEVICE_LOCAL.0;
12554            first = false;
12555        }
12556        if remaining & Self::HOST_VISIBLE.0 != 0 {
12557            if !first {
12558                f.write_str(" | ")?;
12559            }
12560            f.write_str("HOST_VISIBLE")?;
12561            remaining &= !Self::HOST_VISIBLE.0;
12562            first = false;
12563        }
12564        if remaining & Self::HOST_COHERENT.0 != 0 {
12565            if !first {
12566                f.write_str(" | ")?;
12567            }
12568            f.write_str("HOST_COHERENT")?;
12569            remaining &= !Self::HOST_COHERENT.0;
12570            first = false;
12571        }
12572        if remaining & Self::HOST_CACHED.0 != 0 {
12573            if !first {
12574                f.write_str(" | ")?;
12575            }
12576            f.write_str("HOST_CACHED")?;
12577            remaining &= !Self::HOST_CACHED.0;
12578            first = false;
12579        }
12580        if remaining & Self::LAZILY_ALLOCATED.0 != 0 {
12581            if !first {
12582                f.write_str(" | ")?;
12583            }
12584            f.write_str("LAZILY_ALLOCATED")?;
12585            remaining &= !Self::LAZILY_ALLOCATED.0;
12586            first = false;
12587        }
12588        if remaining & Self::PROTECTED.0 != 0 {
12589            if !first {
12590                f.write_str(" | ")?;
12591            }
12592            f.write_str("PROTECTED")?;
12593            remaining &= !Self::PROTECTED.0;
12594            first = false;
12595        }
12596        if remaining & Self::DEVICE_COHERENT.0 != 0 {
12597            if !first {
12598                f.write_str(" | ")?;
12599            }
12600            f.write_str("DEVICE_COHERENT")?;
12601            remaining &= !Self::DEVICE_COHERENT.0;
12602            first = false;
12603        }
12604        if remaining & Self::DEVICE_UNCACHED.0 != 0 {
12605            if !first {
12606                f.write_str(" | ")?;
12607            }
12608            f.write_str("DEVICE_UNCACHED")?;
12609            remaining &= !Self::DEVICE_UNCACHED.0;
12610            first = false;
12611        }
12612        if remaining & Self::RDMA_CAPABLE.0 != 0 {
12613            if !first {
12614                f.write_str(" | ")?;
12615            }
12616            f.write_str("RDMA_CAPABLE")?;
12617            remaining &= !Self::RDMA_CAPABLE.0;
12618            first = false;
12619        }
12620        if remaining != 0u32 {
12621            if !first {
12622                f.write_str(" | ")?;
12623            }
12624            write!(f, "{:#x}", remaining)?;
12625        } else if first {
12626            f.write_str("(empty)")?;
12627        }
12628        Ok(())
12629    }
12630}
12631///[`VkMemoryUnmapFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryUnmapFlagBits.html)
12632#[repr(transparent)]
12633#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
12634#[doc(alias = "VkMemoryUnmapFlagBits")]
12635pub struct MemoryUnmapFlagBits(u32);
12636impl MemoryUnmapFlagBits {
12637    #[inline]
12638    pub const fn empty() -> Self {
12639        Self(0u32)
12640    }
12641    #[inline]
12642    pub const fn from_raw(value: u32) -> Self {
12643        Self(value)
12644    }
12645    #[inline]
12646    pub const fn as_raw(self) -> u32 {
12647        self.0
12648    }
12649    #[inline]
12650    pub const fn is_empty(self) -> bool {
12651        self.0 == 0u32
12652    }
12653    #[inline]
12654    pub const fn contains(self, other: Self) -> bool {
12655        (self.0 & other.0) == other.0
12656    }
12657    #[inline]
12658    pub const fn all() -> Self {
12659        Self(1u32)
12660    }
12661    ///Bit 0.
12662    pub const RESERVE: Self = Self(1u32);
12663}
12664impl core::ops::BitOr for MemoryUnmapFlagBits {
12665    type Output = Self;
12666    #[inline]
12667    fn bitor(self, rhs: Self) -> Self {
12668        Self(self.0 | rhs.0)
12669    }
12670}
12671impl core::ops::BitOrAssign for MemoryUnmapFlagBits {
12672    #[inline]
12673    fn bitor_assign(&mut self, rhs: Self) {
12674        self.0 |= rhs.0;
12675    }
12676}
12677impl core::ops::BitAnd for MemoryUnmapFlagBits {
12678    type Output = Self;
12679    #[inline]
12680    fn bitand(self, rhs: Self) -> Self {
12681        Self(self.0 & rhs.0)
12682    }
12683}
12684impl core::ops::BitAndAssign for MemoryUnmapFlagBits {
12685    #[inline]
12686    fn bitand_assign(&mut self, rhs: Self) {
12687        self.0 &= rhs.0;
12688    }
12689}
12690impl core::ops::BitXor for MemoryUnmapFlagBits {
12691    type Output = Self;
12692    #[inline]
12693    fn bitxor(self, rhs: Self) -> Self {
12694        Self(self.0 ^ rhs.0)
12695    }
12696}
12697impl core::ops::BitXorAssign for MemoryUnmapFlagBits {
12698    #[inline]
12699    fn bitxor_assign(&mut self, rhs: Self) {
12700        self.0 ^= rhs.0;
12701    }
12702}
12703impl core::ops::Not for MemoryUnmapFlagBits {
12704    type Output = Self;
12705    #[inline]
12706    fn not(self) -> Self {
12707        Self(!self.0)
12708    }
12709}
12710impl core::fmt::Debug for MemoryUnmapFlagBits {
12711    #[allow(unused_mut, unused_variables)]
12712    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12713        let mut first = true;
12714        let mut remaining = self.0;
12715        if remaining & Self::RESERVE.0 != 0 {
12716            if !first {
12717                f.write_str(" | ")?;
12718            }
12719            f.write_str("RESERVE")?;
12720            remaining &= !Self::RESERVE.0;
12721            first = false;
12722        }
12723        if remaining != 0u32 {
12724            if !first {
12725                f.write_str(" | ")?;
12726            }
12727            write!(f, "{:#x}", remaining)?;
12728        } else if first {
12729            f.write_str("(empty)")?;
12730        }
12731        Ok(())
12732    }
12733}
12734///[`VkMicromapCreateFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapCreateFlagBitsEXT.html)
12735#[repr(transparent)]
12736#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
12737#[doc(alias = "VkMicromapCreateFlagBitsEXT")]
12738pub struct MicromapCreateFlagBitsEXT(u32);
12739impl MicromapCreateFlagBitsEXT {
12740    #[inline]
12741    pub const fn empty() -> Self {
12742        Self(0u32)
12743    }
12744    #[inline]
12745    pub const fn from_raw(value: u32) -> Self {
12746        Self(value)
12747    }
12748    #[inline]
12749    pub const fn as_raw(self) -> u32 {
12750        self.0
12751    }
12752    #[inline]
12753    pub const fn is_empty(self) -> bool {
12754        self.0 == 0u32
12755    }
12756    #[inline]
12757    pub const fn contains(self, other: Self) -> bool {
12758        (self.0 & other.0) == other.0
12759    }
12760    #[inline]
12761    pub const fn all() -> Self {
12762        Self(1u32)
12763    }
12764    ///Bit 0.
12765    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(1u32);
12766}
12767impl core::ops::BitOr for MicromapCreateFlagBitsEXT {
12768    type Output = Self;
12769    #[inline]
12770    fn bitor(self, rhs: Self) -> Self {
12771        Self(self.0 | rhs.0)
12772    }
12773}
12774impl core::ops::BitOrAssign for MicromapCreateFlagBitsEXT {
12775    #[inline]
12776    fn bitor_assign(&mut self, rhs: Self) {
12777        self.0 |= rhs.0;
12778    }
12779}
12780impl core::ops::BitAnd for MicromapCreateFlagBitsEXT {
12781    type Output = Self;
12782    #[inline]
12783    fn bitand(self, rhs: Self) -> Self {
12784        Self(self.0 & rhs.0)
12785    }
12786}
12787impl core::ops::BitAndAssign for MicromapCreateFlagBitsEXT {
12788    #[inline]
12789    fn bitand_assign(&mut self, rhs: Self) {
12790        self.0 &= rhs.0;
12791    }
12792}
12793impl core::ops::BitXor for MicromapCreateFlagBitsEXT {
12794    type Output = Self;
12795    #[inline]
12796    fn bitxor(self, rhs: Self) -> Self {
12797        Self(self.0 ^ rhs.0)
12798    }
12799}
12800impl core::ops::BitXorAssign for MicromapCreateFlagBitsEXT {
12801    #[inline]
12802    fn bitxor_assign(&mut self, rhs: Self) {
12803        self.0 ^= rhs.0;
12804    }
12805}
12806impl core::ops::Not for MicromapCreateFlagBitsEXT {
12807    type Output = Self;
12808    #[inline]
12809    fn not(self) -> Self {
12810        Self(!self.0)
12811    }
12812}
12813impl core::fmt::Debug for MicromapCreateFlagBitsEXT {
12814    #[allow(unused_mut, unused_variables)]
12815    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12816        let mut first = true;
12817        let mut remaining = self.0;
12818        if remaining & Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0 != 0 {
12819            if !first {
12820                f.write_str(" | ")?;
12821            }
12822            f.write_str("DEVICE_ADDRESS_CAPTURE_REPLAY")?;
12823            remaining &= !Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0;
12824            first = false;
12825        }
12826        if remaining != 0u32 {
12827            if !first {
12828                f.write_str(" | ")?;
12829            }
12830            write!(f, "{:#x}", remaining)?;
12831        } else if first {
12832            f.write_str("(empty)")?;
12833        }
12834        Ok(())
12835    }
12836}
12837///[`VkOpticalFlowExecuteFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowExecuteFlagBitsNV.html)
12838#[repr(transparent)]
12839#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
12840#[doc(alias = "VkOpticalFlowExecuteFlagBitsNV")]
12841pub struct OpticalFlowExecuteFlagBitsNV(u32);
12842impl OpticalFlowExecuteFlagBitsNV {
12843    #[inline]
12844    pub const fn empty() -> Self {
12845        Self(0u32)
12846    }
12847    #[inline]
12848    pub const fn from_raw(value: u32) -> Self {
12849        Self(value)
12850    }
12851    #[inline]
12852    pub const fn as_raw(self) -> u32 {
12853        self.0
12854    }
12855    #[inline]
12856    pub const fn is_empty(self) -> bool {
12857        self.0 == 0u32
12858    }
12859    #[inline]
12860    pub const fn contains(self, other: Self) -> bool {
12861        (self.0 & other.0) == other.0
12862    }
12863    #[inline]
12864    pub const fn all() -> Self {
12865        Self(1u32)
12866    }
12867    ///Bit 0.
12868    pub const DISABLE_TEMPORAL_HINTS: Self = Self(1u32);
12869}
12870impl core::ops::BitOr for OpticalFlowExecuteFlagBitsNV {
12871    type Output = Self;
12872    #[inline]
12873    fn bitor(self, rhs: Self) -> Self {
12874        Self(self.0 | rhs.0)
12875    }
12876}
12877impl core::ops::BitOrAssign for OpticalFlowExecuteFlagBitsNV {
12878    #[inline]
12879    fn bitor_assign(&mut self, rhs: Self) {
12880        self.0 |= rhs.0;
12881    }
12882}
12883impl core::ops::BitAnd for OpticalFlowExecuteFlagBitsNV {
12884    type Output = Self;
12885    #[inline]
12886    fn bitand(self, rhs: Self) -> Self {
12887        Self(self.0 & rhs.0)
12888    }
12889}
12890impl core::ops::BitAndAssign for OpticalFlowExecuteFlagBitsNV {
12891    #[inline]
12892    fn bitand_assign(&mut self, rhs: Self) {
12893        self.0 &= rhs.0;
12894    }
12895}
12896impl core::ops::BitXor for OpticalFlowExecuteFlagBitsNV {
12897    type Output = Self;
12898    #[inline]
12899    fn bitxor(self, rhs: Self) -> Self {
12900        Self(self.0 ^ rhs.0)
12901    }
12902}
12903impl core::ops::BitXorAssign for OpticalFlowExecuteFlagBitsNV {
12904    #[inline]
12905    fn bitxor_assign(&mut self, rhs: Self) {
12906        self.0 ^= rhs.0;
12907    }
12908}
12909impl core::ops::Not for OpticalFlowExecuteFlagBitsNV {
12910    type Output = Self;
12911    #[inline]
12912    fn not(self) -> Self {
12913        Self(!self.0)
12914    }
12915}
12916impl core::fmt::Debug for OpticalFlowExecuteFlagBitsNV {
12917    #[allow(unused_mut, unused_variables)]
12918    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12919        let mut first = true;
12920        let mut remaining = self.0;
12921        if remaining & Self::DISABLE_TEMPORAL_HINTS.0 != 0 {
12922            if !first {
12923                f.write_str(" | ")?;
12924            }
12925            f.write_str("DISABLE_TEMPORAL_HINTS")?;
12926            remaining &= !Self::DISABLE_TEMPORAL_HINTS.0;
12927            first = false;
12928        }
12929        if remaining != 0u32 {
12930            if !first {
12931                f.write_str(" | ")?;
12932            }
12933            write!(f, "{:#x}", remaining)?;
12934        } else if first {
12935            f.write_str("(empty)")?;
12936        }
12937        Ok(())
12938    }
12939}
12940///[`VkOpticalFlowGridSizeFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowGridSizeFlagBitsNV.html)
12941#[repr(transparent)]
12942#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
12943#[doc(alias = "VkOpticalFlowGridSizeFlagBitsNV")]
12944pub struct OpticalFlowGridSizeFlagBitsNV(u32);
12945impl OpticalFlowGridSizeFlagBitsNV {
12946    #[inline]
12947    pub const fn empty() -> Self {
12948        Self(0u32)
12949    }
12950    #[inline]
12951    pub const fn from_raw(value: u32) -> Self {
12952        Self(value)
12953    }
12954    #[inline]
12955    pub const fn as_raw(self) -> u32 {
12956        self.0
12957    }
12958    #[inline]
12959    pub const fn is_empty(self) -> bool {
12960        self.0 == 0u32
12961    }
12962    #[inline]
12963    pub const fn contains(self, other: Self) -> bool {
12964        (self.0 & other.0) == other.0
12965    }
12966    #[inline]
12967    pub const fn all() -> Self {
12968        Self(15u32)
12969    }
12970    pub const UNKNOWN: Self = Self(0u32);
12971    ///Bit 0.
12972    pub const _1X1: Self = Self(1u32);
12973    ///Bit 1.
12974    pub const _2X2: Self = Self(2u32);
12975    ///Bit 2.
12976    pub const _4X4: Self = Self(4u32);
12977    ///Bit 3.
12978    pub const _8X8: Self = Self(8u32);
12979}
12980impl core::ops::BitOr for OpticalFlowGridSizeFlagBitsNV {
12981    type Output = Self;
12982    #[inline]
12983    fn bitor(self, rhs: Self) -> Self {
12984        Self(self.0 | rhs.0)
12985    }
12986}
12987impl core::ops::BitOrAssign for OpticalFlowGridSizeFlagBitsNV {
12988    #[inline]
12989    fn bitor_assign(&mut self, rhs: Self) {
12990        self.0 |= rhs.0;
12991    }
12992}
12993impl core::ops::BitAnd for OpticalFlowGridSizeFlagBitsNV {
12994    type Output = Self;
12995    #[inline]
12996    fn bitand(self, rhs: Self) -> Self {
12997        Self(self.0 & rhs.0)
12998    }
12999}
13000impl core::ops::BitAndAssign for OpticalFlowGridSizeFlagBitsNV {
13001    #[inline]
13002    fn bitand_assign(&mut self, rhs: Self) {
13003        self.0 &= rhs.0;
13004    }
13005}
13006impl core::ops::BitXor for OpticalFlowGridSizeFlagBitsNV {
13007    type Output = Self;
13008    #[inline]
13009    fn bitxor(self, rhs: Self) -> Self {
13010        Self(self.0 ^ rhs.0)
13011    }
13012}
13013impl core::ops::BitXorAssign for OpticalFlowGridSizeFlagBitsNV {
13014    #[inline]
13015    fn bitxor_assign(&mut self, rhs: Self) {
13016        self.0 ^= rhs.0;
13017    }
13018}
13019impl core::ops::Not for OpticalFlowGridSizeFlagBitsNV {
13020    type Output = Self;
13021    #[inline]
13022    fn not(self) -> Self {
13023        Self(!self.0)
13024    }
13025}
13026impl core::fmt::Debug for OpticalFlowGridSizeFlagBitsNV {
13027    #[allow(unused_mut, unused_variables)]
13028    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13029        let mut first = true;
13030        let mut remaining = self.0;
13031        if remaining & Self::_1X1.0 != 0 {
13032            if !first {
13033                f.write_str(" | ")?;
13034            }
13035            f.write_str("_1X1")?;
13036            remaining &= !Self::_1X1.0;
13037            first = false;
13038        }
13039        if remaining & Self::_2X2.0 != 0 {
13040            if !first {
13041                f.write_str(" | ")?;
13042            }
13043            f.write_str("_2X2")?;
13044            remaining &= !Self::_2X2.0;
13045            first = false;
13046        }
13047        if remaining & Self::_4X4.0 != 0 {
13048            if !first {
13049                f.write_str(" | ")?;
13050            }
13051            f.write_str("_4X4")?;
13052            remaining &= !Self::_4X4.0;
13053            first = false;
13054        }
13055        if remaining & Self::_8X8.0 != 0 {
13056            if !first {
13057                f.write_str(" | ")?;
13058            }
13059            f.write_str("_8X8")?;
13060            remaining &= !Self::_8X8.0;
13061            first = false;
13062        }
13063        if remaining != 0u32 {
13064            if !first {
13065                f.write_str(" | ")?;
13066            }
13067            write!(f, "{:#x}", remaining)?;
13068        } else if first {
13069            f.write_str("(empty)")?;
13070        }
13071        Ok(())
13072    }
13073}
13074///[`VkOpticalFlowSessionCreateFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateFlagBitsNV.html)
13075#[repr(transparent)]
13076#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
13077#[doc(alias = "VkOpticalFlowSessionCreateFlagBitsNV")]
13078pub struct OpticalFlowSessionCreateFlagBitsNV(u32);
13079impl OpticalFlowSessionCreateFlagBitsNV {
13080    #[inline]
13081    pub const fn empty() -> Self {
13082        Self(0u32)
13083    }
13084    #[inline]
13085    pub const fn from_raw(value: u32) -> Self {
13086        Self(value)
13087    }
13088    #[inline]
13089    pub const fn as_raw(self) -> u32 {
13090        self.0
13091    }
13092    #[inline]
13093    pub const fn is_empty(self) -> bool {
13094        self.0 == 0u32
13095    }
13096    #[inline]
13097    pub const fn contains(self, other: Self) -> bool {
13098        (self.0 & other.0) == other.0
13099    }
13100    #[inline]
13101    pub const fn all() -> Self {
13102        Self(31u32)
13103    }
13104    ///Bit 0.
13105    pub const ENABLE_HINT: Self = Self(1u32);
13106    ///Bit 1.
13107    pub const ENABLE_COST: Self = Self(2u32);
13108    ///Bit 2.
13109    pub const ENABLE_GLOBAL_FLOW: Self = Self(4u32);
13110    ///Bit 3.
13111    pub const ALLOW_REGIONS: Self = Self(8u32);
13112    ///Bit 4.
13113    pub const BOTH_DIRECTIONS: Self = Self(16u32);
13114}
13115impl core::ops::BitOr for OpticalFlowSessionCreateFlagBitsNV {
13116    type Output = Self;
13117    #[inline]
13118    fn bitor(self, rhs: Self) -> Self {
13119        Self(self.0 | rhs.0)
13120    }
13121}
13122impl core::ops::BitOrAssign for OpticalFlowSessionCreateFlagBitsNV {
13123    #[inline]
13124    fn bitor_assign(&mut self, rhs: Self) {
13125        self.0 |= rhs.0;
13126    }
13127}
13128impl core::ops::BitAnd for OpticalFlowSessionCreateFlagBitsNV {
13129    type Output = Self;
13130    #[inline]
13131    fn bitand(self, rhs: Self) -> Self {
13132        Self(self.0 & rhs.0)
13133    }
13134}
13135impl core::ops::BitAndAssign for OpticalFlowSessionCreateFlagBitsNV {
13136    #[inline]
13137    fn bitand_assign(&mut self, rhs: Self) {
13138        self.0 &= rhs.0;
13139    }
13140}
13141impl core::ops::BitXor for OpticalFlowSessionCreateFlagBitsNV {
13142    type Output = Self;
13143    #[inline]
13144    fn bitxor(self, rhs: Self) -> Self {
13145        Self(self.0 ^ rhs.0)
13146    }
13147}
13148impl core::ops::BitXorAssign for OpticalFlowSessionCreateFlagBitsNV {
13149    #[inline]
13150    fn bitxor_assign(&mut self, rhs: Self) {
13151        self.0 ^= rhs.0;
13152    }
13153}
13154impl core::ops::Not for OpticalFlowSessionCreateFlagBitsNV {
13155    type Output = Self;
13156    #[inline]
13157    fn not(self) -> Self {
13158        Self(!self.0)
13159    }
13160}
13161impl core::fmt::Debug for OpticalFlowSessionCreateFlagBitsNV {
13162    #[allow(unused_mut, unused_variables)]
13163    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13164        let mut first = true;
13165        let mut remaining = self.0;
13166        if remaining & Self::ENABLE_HINT.0 != 0 {
13167            if !first {
13168                f.write_str(" | ")?;
13169            }
13170            f.write_str("ENABLE_HINT")?;
13171            remaining &= !Self::ENABLE_HINT.0;
13172            first = false;
13173        }
13174        if remaining & Self::ENABLE_COST.0 != 0 {
13175            if !first {
13176                f.write_str(" | ")?;
13177            }
13178            f.write_str("ENABLE_COST")?;
13179            remaining &= !Self::ENABLE_COST.0;
13180            first = false;
13181        }
13182        if remaining & Self::ENABLE_GLOBAL_FLOW.0 != 0 {
13183            if !first {
13184                f.write_str(" | ")?;
13185            }
13186            f.write_str("ENABLE_GLOBAL_FLOW")?;
13187            remaining &= !Self::ENABLE_GLOBAL_FLOW.0;
13188            first = false;
13189        }
13190        if remaining & Self::ALLOW_REGIONS.0 != 0 {
13191            if !first {
13192                f.write_str(" | ")?;
13193            }
13194            f.write_str("ALLOW_REGIONS")?;
13195            remaining &= !Self::ALLOW_REGIONS.0;
13196            first = false;
13197        }
13198        if remaining & Self::BOTH_DIRECTIONS.0 != 0 {
13199            if !first {
13200                f.write_str(" | ")?;
13201            }
13202            f.write_str("BOTH_DIRECTIONS")?;
13203            remaining &= !Self::BOTH_DIRECTIONS.0;
13204            first = false;
13205        }
13206        if remaining != 0u32 {
13207            if !first {
13208                f.write_str(" | ")?;
13209            }
13210            write!(f, "{:#x}", remaining)?;
13211        } else if first {
13212            f.write_str("(empty)")?;
13213        }
13214        Ok(())
13215    }
13216}
13217///[`VkOpticalFlowUsageFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowUsageFlagBitsNV.html)
13218#[repr(transparent)]
13219#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
13220#[doc(alias = "VkOpticalFlowUsageFlagBitsNV")]
13221pub struct OpticalFlowUsageFlagBitsNV(u32);
13222impl OpticalFlowUsageFlagBitsNV {
13223    #[inline]
13224    pub const fn empty() -> Self {
13225        Self(0u32)
13226    }
13227    #[inline]
13228    pub const fn from_raw(value: u32) -> Self {
13229        Self(value)
13230    }
13231    #[inline]
13232    pub const fn as_raw(self) -> u32 {
13233        self.0
13234    }
13235    #[inline]
13236    pub const fn is_empty(self) -> bool {
13237        self.0 == 0u32
13238    }
13239    #[inline]
13240    pub const fn contains(self, other: Self) -> bool {
13241        (self.0 & other.0) == other.0
13242    }
13243    #[inline]
13244    pub const fn all() -> Self {
13245        Self(31u32)
13246    }
13247    pub const UNKNOWN: Self = Self(0u32);
13248    ///Bit 0.
13249    pub const INPUT: Self = Self(1u32);
13250    ///Bit 1.
13251    pub const OUTPUT: Self = Self(2u32);
13252    ///Bit 2.
13253    pub const HINT: Self = Self(4u32);
13254    ///Bit 3.
13255    pub const COST: Self = Self(8u32);
13256    ///Bit 4.
13257    pub const GLOBAL_FLOW: Self = Self(16u32);
13258}
13259impl core::ops::BitOr for OpticalFlowUsageFlagBitsNV {
13260    type Output = Self;
13261    #[inline]
13262    fn bitor(self, rhs: Self) -> Self {
13263        Self(self.0 | rhs.0)
13264    }
13265}
13266impl core::ops::BitOrAssign for OpticalFlowUsageFlagBitsNV {
13267    #[inline]
13268    fn bitor_assign(&mut self, rhs: Self) {
13269        self.0 |= rhs.0;
13270    }
13271}
13272impl core::ops::BitAnd for OpticalFlowUsageFlagBitsNV {
13273    type Output = Self;
13274    #[inline]
13275    fn bitand(self, rhs: Self) -> Self {
13276        Self(self.0 & rhs.0)
13277    }
13278}
13279impl core::ops::BitAndAssign for OpticalFlowUsageFlagBitsNV {
13280    #[inline]
13281    fn bitand_assign(&mut self, rhs: Self) {
13282        self.0 &= rhs.0;
13283    }
13284}
13285impl core::ops::BitXor for OpticalFlowUsageFlagBitsNV {
13286    type Output = Self;
13287    #[inline]
13288    fn bitxor(self, rhs: Self) -> Self {
13289        Self(self.0 ^ rhs.0)
13290    }
13291}
13292impl core::ops::BitXorAssign for OpticalFlowUsageFlagBitsNV {
13293    #[inline]
13294    fn bitxor_assign(&mut self, rhs: Self) {
13295        self.0 ^= rhs.0;
13296    }
13297}
13298impl core::ops::Not for OpticalFlowUsageFlagBitsNV {
13299    type Output = Self;
13300    #[inline]
13301    fn not(self) -> Self {
13302        Self(!self.0)
13303    }
13304}
13305impl core::fmt::Debug for OpticalFlowUsageFlagBitsNV {
13306    #[allow(unused_mut, unused_variables)]
13307    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13308        let mut first = true;
13309        let mut remaining = self.0;
13310        if remaining & Self::INPUT.0 != 0 {
13311            if !first {
13312                f.write_str(" | ")?;
13313            }
13314            f.write_str("INPUT")?;
13315            remaining &= !Self::INPUT.0;
13316            first = false;
13317        }
13318        if remaining & Self::OUTPUT.0 != 0 {
13319            if !first {
13320                f.write_str(" | ")?;
13321            }
13322            f.write_str("OUTPUT")?;
13323            remaining &= !Self::OUTPUT.0;
13324            first = false;
13325        }
13326        if remaining & Self::HINT.0 != 0 {
13327            if !first {
13328                f.write_str(" | ")?;
13329            }
13330            f.write_str("HINT")?;
13331            remaining &= !Self::HINT.0;
13332            first = false;
13333        }
13334        if remaining & Self::COST.0 != 0 {
13335            if !first {
13336                f.write_str(" | ")?;
13337            }
13338            f.write_str("COST")?;
13339            remaining &= !Self::COST.0;
13340            first = false;
13341        }
13342        if remaining & Self::GLOBAL_FLOW.0 != 0 {
13343            if !first {
13344                f.write_str(" | ")?;
13345            }
13346            f.write_str("GLOBAL_FLOW")?;
13347            remaining &= !Self::GLOBAL_FLOW.0;
13348            first = false;
13349        }
13350        if remaining != 0u32 {
13351            if !first {
13352                f.write_str(" | ")?;
13353            }
13354            write!(f, "{:#x}", remaining)?;
13355        } else if first {
13356            f.write_str("(empty)")?;
13357        }
13358        Ok(())
13359    }
13360}
13361///[`VkPartitionedAccelerationStructureInstanceFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstanceFlagBitsNV.html)
13362#[repr(transparent)]
13363#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
13364#[doc(alias = "VkPartitionedAccelerationStructureInstanceFlagBitsNV")]
13365pub struct PartitionedAccelerationStructureInstanceFlagBitsNV(u32);
13366impl PartitionedAccelerationStructureInstanceFlagBitsNV {
13367    #[inline]
13368    pub const fn empty() -> Self {
13369        Self(0u32)
13370    }
13371    #[inline]
13372    pub const fn from_raw(value: u32) -> Self {
13373        Self(value)
13374    }
13375    #[inline]
13376    pub const fn as_raw(self) -> u32 {
13377        self.0
13378    }
13379    #[inline]
13380    pub const fn is_empty(self) -> bool {
13381        self.0 == 0u32
13382    }
13383    #[inline]
13384    pub const fn contains(self, other: Self) -> bool {
13385        (self.0 & other.0) == other.0
13386    }
13387    #[inline]
13388    pub const fn all() -> Self {
13389        Self(31u32)
13390    }
13391    ///Bit 0.
13392    pub const FLAG_TRIANGLE_FACING_CULL_DISABLE: Self = Self(1u32);
13393    ///Bit 1.
13394    pub const FLAG_TRIANGLE_FLIP_FACING: Self = Self(2u32);
13395    ///Bit 2.
13396    pub const FLAG_FORCE_OPAQUE: Self = Self(4u32);
13397    ///Bit 3.
13398    pub const FLAG_FORCE_NO_OPAQUE: Self = Self(8u32);
13399    ///Bit 4.
13400    pub const FLAG_ENABLE_EXPLICIT_BOUNDING_BOX: Self = Self(16u32);
13401}
13402impl core::ops::BitOr for PartitionedAccelerationStructureInstanceFlagBitsNV {
13403    type Output = Self;
13404    #[inline]
13405    fn bitor(self, rhs: Self) -> Self {
13406        Self(self.0 | rhs.0)
13407    }
13408}
13409impl core::ops::BitOrAssign for PartitionedAccelerationStructureInstanceFlagBitsNV {
13410    #[inline]
13411    fn bitor_assign(&mut self, rhs: Self) {
13412        self.0 |= rhs.0;
13413    }
13414}
13415impl core::ops::BitAnd for PartitionedAccelerationStructureInstanceFlagBitsNV {
13416    type Output = Self;
13417    #[inline]
13418    fn bitand(self, rhs: Self) -> Self {
13419        Self(self.0 & rhs.0)
13420    }
13421}
13422impl core::ops::BitAndAssign for PartitionedAccelerationStructureInstanceFlagBitsNV {
13423    #[inline]
13424    fn bitand_assign(&mut self, rhs: Self) {
13425        self.0 &= rhs.0;
13426    }
13427}
13428impl core::ops::BitXor for PartitionedAccelerationStructureInstanceFlagBitsNV {
13429    type Output = Self;
13430    #[inline]
13431    fn bitxor(self, rhs: Self) -> Self {
13432        Self(self.0 ^ rhs.0)
13433    }
13434}
13435impl core::ops::BitXorAssign for PartitionedAccelerationStructureInstanceFlagBitsNV {
13436    #[inline]
13437    fn bitxor_assign(&mut self, rhs: Self) {
13438        self.0 ^= rhs.0;
13439    }
13440}
13441impl core::ops::Not for PartitionedAccelerationStructureInstanceFlagBitsNV {
13442    type Output = Self;
13443    #[inline]
13444    fn not(self) -> Self {
13445        Self(!self.0)
13446    }
13447}
13448impl core::fmt::Debug for PartitionedAccelerationStructureInstanceFlagBitsNV {
13449    #[allow(unused_mut, unused_variables)]
13450    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13451        let mut first = true;
13452        let mut remaining = self.0;
13453        if remaining & Self::FLAG_TRIANGLE_FACING_CULL_DISABLE.0 != 0 {
13454            if !first {
13455                f.write_str(" | ")?;
13456            }
13457            f.write_str("FLAG_TRIANGLE_FACING_CULL_DISABLE")?;
13458            remaining &= !Self::FLAG_TRIANGLE_FACING_CULL_DISABLE.0;
13459            first = false;
13460        }
13461        if remaining & Self::FLAG_TRIANGLE_FLIP_FACING.0 != 0 {
13462            if !first {
13463                f.write_str(" | ")?;
13464            }
13465            f.write_str("FLAG_TRIANGLE_FLIP_FACING")?;
13466            remaining &= !Self::FLAG_TRIANGLE_FLIP_FACING.0;
13467            first = false;
13468        }
13469        if remaining & Self::FLAG_FORCE_OPAQUE.0 != 0 {
13470            if !first {
13471                f.write_str(" | ")?;
13472            }
13473            f.write_str("FLAG_FORCE_OPAQUE")?;
13474            remaining &= !Self::FLAG_FORCE_OPAQUE.0;
13475            first = false;
13476        }
13477        if remaining & Self::FLAG_FORCE_NO_OPAQUE.0 != 0 {
13478            if !first {
13479                f.write_str(" | ")?;
13480            }
13481            f.write_str("FLAG_FORCE_NO_OPAQUE")?;
13482            remaining &= !Self::FLAG_FORCE_NO_OPAQUE.0;
13483            first = false;
13484        }
13485        if remaining & Self::FLAG_ENABLE_EXPLICIT_BOUNDING_BOX.0 != 0 {
13486            if !first {
13487                f.write_str(" | ")?;
13488            }
13489            f.write_str("FLAG_ENABLE_EXPLICIT_BOUNDING_BOX")?;
13490            remaining &= !Self::FLAG_ENABLE_EXPLICIT_BOUNDING_BOX.0;
13491            first = false;
13492        }
13493        if remaining != 0u32 {
13494            if !first {
13495                f.write_str(" | ")?;
13496            }
13497            write!(f, "{:#x}", remaining)?;
13498        } else if first {
13499            f.write_str("(empty)")?;
13500        }
13501        Ok(())
13502    }
13503}
13504///[`VkPastPresentationTimingFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingFlagBitsEXT.html)
13505#[repr(transparent)]
13506#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
13507#[doc(alias = "VkPastPresentationTimingFlagBitsEXT")]
13508pub struct PastPresentationTimingFlagBitsEXT(u32);
13509impl PastPresentationTimingFlagBitsEXT {
13510    #[inline]
13511    pub const fn empty() -> Self {
13512        Self(0u32)
13513    }
13514    #[inline]
13515    pub const fn from_raw(value: u32) -> Self {
13516        Self(value)
13517    }
13518    #[inline]
13519    pub const fn as_raw(self) -> u32 {
13520        self.0
13521    }
13522    #[inline]
13523    pub const fn is_empty(self) -> bool {
13524        self.0 == 0u32
13525    }
13526    #[inline]
13527    pub const fn contains(self, other: Self) -> bool {
13528        (self.0 & other.0) == other.0
13529    }
13530    #[inline]
13531    pub const fn all() -> Self {
13532        Self(3u32)
13533    }
13534    ///Bit 0.
13535    pub const ALLOW_PARTIAL_RESULTS: Self = Self(1u32);
13536    ///Bit 1.
13537    pub const ALLOW_OUT_OF_ORDER_RESULTS: Self = Self(2u32);
13538}
13539impl core::ops::BitOr for PastPresentationTimingFlagBitsEXT {
13540    type Output = Self;
13541    #[inline]
13542    fn bitor(self, rhs: Self) -> Self {
13543        Self(self.0 | rhs.0)
13544    }
13545}
13546impl core::ops::BitOrAssign for PastPresentationTimingFlagBitsEXT {
13547    #[inline]
13548    fn bitor_assign(&mut self, rhs: Self) {
13549        self.0 |= rhs.0;
13550    }
13551}
13552impl core::ops::BitAnd for PastPresentationTimingFlagBitsEXT {
13553    type Output = Self;
13554    #[inline]
13555    fn bitand(self, rhs: Self) -> Self {
13556        Self(self.0 & rhs.0)
13557    }
13558}
13559impl core::ops::BitAndAssign for PastPresentationTimingFlagBitsEXT {
13560    #[inline]
13561    fn bitand_assign(&mut self, rhs: Self) {
13562        self.0 &= rhs.0;
13563    }
13564}
13565impl core::ops::BitXor for PastPresentationTimingFlagBitsEXT {
13566    type Output = Self;
13567    #[inline]
13568    fn bitxor(self, rhs: Self) -> Self {
13569        Self(self.0 ^ rhs.0)
13570    }
13571}
13572impl core::ops::BitXorAssign for PastPresentationTimingFlagBitsEXT {
13573    #[inline]
13574    fn bitxor_assign(&mut self, rhs: Self) {
13575        self.0 ^= rhs.0;
13576    }
13577}
13578impl core::ops::Not for PastPresentationTimingFlagBitsEXT {
13579    type Output = Self;
13580    #[inline]
13581    fn not(self) -> Self {
13582        Self(!self.0)
13583    }
13584}
13585impl core::fmt::Debug for PastPresentationTimingFlagBitsEXT {
13586    #[allow(unused_mut, unused_variables)]
13587    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13588        let mut first = true;
13589        let mut remaining = self.0;
13590        if remaining & Self::ALLOW_PARTIAL_RESULTS.0 != 0 {
13591            if !first {
13592                f.write_str(" | ")?;
13593            }
13594            f.write_str("ALLOW_PARTIAL_RESULTS")?;
13595            remaining &= !Self::ALLOW_PARTIAL_RESULTS.0;
13596            first = false;
13597        }
13598        if remaining & Self::ALLOW_OUT_OF_ORDER_RESULTS.0 != 0 {
13599            if !first {
13600                f.write_str(" | ")?;
13601            }
13602            f.write_str("ALLOW_OUT_OF_ORDER_RESULTS")?;
13603            remaining &= !Self::ALLOW_OUT_OF_ORDER_RESULTS.0;
13604            first = false;
13605        }
13606        if remaining != 0u32 {
13607            if !first {
13608                f.write_str(" | ")?;
13609            }
13610            write!(f, "{:#x}", remaining)?;
13611        } else if first {
13612            f.write_str("(empty)")?;
13613        }
13614        Ok(())
13615    }
13616}
13617///[`VkPeerMemoryFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPeerMemoryFeatureFlagBits.html)
13618#[repr(transparent)]
13619#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
13620#[doc(alias = "VkPeerMemoryFeatureFlagBits")]
13621pub struct PeerMemoryFeatureFlagBits(u32);
13622impl PeerMemoryFeatureFlagBits {
13623    #[inline]
13624    pub const fn empty() -> Self {
13625        Self(0u32)
13626    }
13627    #[inline]
13628    pub const fn from_raw(value: u32) -> Self {
13629        Self(value)
13630    }
13631    #[inline]
13632    pub const fn as_raw(self) -> u32 {
13633        self.0
13634    }
13635    #[inline]
13636    pub const fn is_empty(self) -> bool {
13637        self.0 == 0u32
13638    }
13639    #[inline]
13640    pub const fn contains(self, other: Self) -> bool {
13641        (self.0 & other.0) == other.0
13642    }
13643    #[inline]
13644    pub const fn all() -> Self {
13645        Self(15u32)
13646    }
13647    ///Bit 0.
13648    pub const COPY_SRC: Self = Self(1u32);
13649    ///Bit 1.
13650    pub const COPY_DST: Self = Self(2u32);
13651    ///Bit 2.
13652    pub const GENERIC_SRC: Self = Self(4u32);
13653    ///Bit 3.
13654    pub const GENERIC_DST: Self = Self(8u32);
13655}
13656impl core::ops::BitOr for PeerMemoryFeatureFlagBits {
13657    type Output = Self;
13658    #[inline]
13659    fn bitor(self, rhs: Self) -> Self {
13660        Self(self.0 | rhs.0)
13661    }
13662}
13663impl core::ops::BitOrAssign for PeerMemoryFeatureFlagBits {
13664    #[inline]
13665    fn bitor_assign(&mut self, rhs: Self) {
13666        self.0 |= rhs.0;
13667    }
13668}
13669impl core::ops::BitAnd for PeerMemoryFeatureFlagBits {
13670    type Output = Self;
13671    #[inline]
13672    fn bitand(self, rhs: Self) -> Self {
13673        Self(self.0 & rhs.0)
13674    }
13675}
13676impl core::ops::BitAndAssign for PeerMemoryFeatureFlagBits {
13677    #[inline]
13678    fn bitand_assign(&mut self, rhs: Self) {
13679        self.0 &= rhs.0;
13680    }
13681}
13682impl core::ops::BitXor for PeerMemoryFeatureFlagBits {
13683    type Output = Self;
13684    #[inline]
13685    fn bitxor(self, rhs: Self) -> Self {
13686        Self(self.0 ^ rhs.0)
13687    }
13688}
13689impl core::ops::BitXorAssign for PeerMemoryFeatureFlagBits {
13690    #[inline]
13691    fn bitxor_assign(&mut self, rhs: Self) {
13692        self.0 ^= rhs.0;
13693    }
13694}
13695impl core::ops::Not for PeerMemoryFeatureFlagBits {
13696    type Output = Self;
13697    #[inline]
13698    fn not(self) -> Self {
13699        Self(!self.0)
13700    }
13701}
13702impl core::fmt::Debug for PeerMemoryFeatureFlagBits {
13703    #[allow(unused_mut, unused_variables)]
13704    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13705        let mut first = true;
13706        let mut remaining = self.0;
13707        if remaining & Self::COPY_SRC.0 != 0 {
13708            if !first {
13709                f.write_str(" | ")?;
13710            }
13711            f.write_str("COPY_SRC")?;
13712            remaining &= !Self::COPY_SRC.0;
13713            first = false;
13714        }
13715        if remaining & Self::COPY_DST.0 != 0 {
13716            if !first {
13717                f.write_str(" | ")?;
13718            }
13719            f.write_str("COPY_DST")?;
13720            remaining &= !Self::COPY_DST.0;
13721            first = false;
13722        }
13723        if remaining & Self::GENERIC_SRC.0 != 0 {
13724            if !first {
13725                f.write_str(" | ")?;
13726            }
13727            f.write_str("GENERIC_SRC")?;
13728            remaining &= !Self::GENERIC_SRC.0;
13729            first = false;
13730        }
13731        if remaining & Self::GENERIC_DST.0 != 0 {
13732            if !first {
13733                f.write_str(" | ")?;
13734            }
13735            f.write_str("GENERIC_DST")?;
13736            remaining &= !Self::GENERIC_DST.0;
13737            first = false;
13738        }
13739        if remaining != 0u32 {
13740            if !first {
13741                f.write_str(" | ")?;
13742            }
13743            write!(f, "{:#x}", remaining)?;
13744        } else if first {
13745            f.write_str("(empty)")?;
13746        }
13747        Ok(())
13748    }
13749}
13750///[`VkPerformanceCounterDescriptionFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html)
13751#[repr(transparent)]
13752#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
13753#[doc(alias = "VkPerformanceCounterDescriptionFlagBitsKHR")]
13754pub struct PerformanceCounterDescriptionFlagBitsKHR(u32);
13755impl PerformanceCounterDescriptionFlagBitsKHR {
13756    #[inline]
13757    pub const fn empty() -> Self {
13758        Self(0u32)
13759    }
13760    #[inline]
13761    pub const fn from_raw(value: u32) -> Self {
13762        Self(value)
13763    }
13764    #[inline]
13765    pub const fn as_raw(self) -> u32 {
13766        self.0
13767    }
13768    #[inline]
13769    pub const fn is_empty(self) -> bool {
13770        self.0 == 0u32
13771    }
13772    #[inline]
13773    pub const fn contains(self, other: Self) -> bool {
13774        (self.0 & other.0) == other.0
13775    }
13776    #[inline]
13777    pub const fn all() -> Self {
13778        Self(3u32)
13779    }
13780    ///Bit 0.
13781    pub const PERFORMANCE_IMPACTING: Self = Self(1u32);
13782    ///Bit 1.
13783    pub const CONCURRENTLY_IMPACTED: Self = Self(2u32);
13784}
13785impl core::ops::BitOr for PerformanceCounterDescriptionFlagBitsKHR {
13786    type Output = Self;
13787    #[inline]
13788    fn bitor(self, rhs: Self) -> Self {
13789        Self(self.0 | rhs.0)
13790    }
13791}
13792impl core::ops::BitOrAssign for PerformanceCounterDescriptionFlagBitsKHR {
13793    #[inline]
13794    fn bitor_assign(&mut self, rhs: Self) {
13795        self.0 |= rhs.0;
13796    }
13797}
13798impl core::ops::BitAnd for PerformanceCounterDescriptionFlagBitsKHR {
13799    type Output = Self;
13800    #[inline]
13801    fn bitand(self, rhs: Self) -> Self {
13802        Self(self.0 & rhs.0)
13803    }
13804}
13805impl core::ops::BitAndAssign for PerformanceCounterDescriptionFlagBitsKHR {
13806    #[inline]
13807    fn bitand_assign(&mut self, rhs: Self) {
13808        self.0 &= rhs.0;
13809    }
13810}
13811impl core::ops::BitXor for PerformanceCounterDescriptionFlagBitsKHR {
13812    type Output = Self;
13813    #[inline]
13814    fn bitxor(self, rhs: Self) -> Self {
13815        Self(self.0 ^ rhs.0)
13816    }
13817}
13818impl core::ops::BitXorAssign for PerformanceCounterDescriptionFlagBitsKHR {
13819    #[inline]
13820    fn bitxor_assign(&mut self, rhs: Self) {
13821        self.0 ^= rhs.0;
13822    }
13823}
13824impl core::ops::Not for PerformanceCounterDescriptionFlagBitsKHR {
13825    type Output = Self;
13826    #[inline]
13827    fn not(self) -> Self {
13828        Self(!self.0)
13829    }
13830}
13831impl core::fmt::Debug for PerformanceCounterDescriptionFlagBitsKHR {
13832    #[allow(unused_mut, unused_variables)]
13833    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13834        let mut first = true;
13835        let mut remaining = self.0;
13836        if remaining & Self::PERFORMANCE_IMPACTING.0 != 0 {
13837            if !first {
13838                f.write_str(" | ")?;
13839            }
13840            f.write_str("PERFORMANCE_IMPACTING")?;
13841            remaining &= !Self::PERFORMANCE_IMPACTING.0;
13842            first = false;
13843        }
13844        if remaining & Self::CONCURRENTLY_IMPACTED.0 != 0 {
13845            if !first {
13846                f.write_str(" | ")?;
13847            }
13848            f.write_str("CONCURRENTLY_IMPACTED")?;
13849            remaining &= !Self::CONCURRENTLY_IMPACTED.0;
13850            first = false;
13851        }
13852        if remaining != 0u32 {
13853            if !first {
13854                f.write_str(" | ")?;
13855            }
13856            write!(f, "{:#x}", remaining)?;
13857        } else if first {
13858            f.write_str("(empty)")?;
13859        }
13860        Ok(())
13861    }
13862}
13863///[`VkPhysicalDeviceSchedulingControlsFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFlagBitsARM.html)
13864#[repr(transparent)]
13865#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
13866#[doc(alias = "VkPhysicalDeviceSchedulingControlsFlagBitsARM")]
13867pub struct PhysicalDeviceSchedulingControlsFlagBitsARM(u64);
13868impl PhysicalDeviceSchedulingControlsFlagBitsARM {
13869    #[inline]
13870    pub const fn empty() -> Self {
13871        Self(0u64)
13872    }
13873    #[inline]
13874    pub const fn from_raw(value: u64) -> Self {
13875        Self(value)
13876    }
13877    #[inline]
13878    pub const fn as_raw(self) -> u64 {
13879        self.0
13880    }
13881    #[inline]
13882    pub const fn is_empty(self) -> bool {
13883        self.0 == 0u64
13884    }
13885    #[inline]
13886    pub const fn contains(self, other: Self) -> bool {
13887        (self.0 & other.0) == other.0
13888    }
13889    #[inline]
13890    pub const fn all() -> Self {
13891        Self(1u64)
13892    }
13893    ///Bit 0.
13894    pub const SHADER_CORE_COUNT: Self = Self(1u64);
13895}
13896impl core::ops::BitOr for PhysicalDeviceSchedulingControlsFlagBitsARM {
13897    type Output = Self;
13898    #[inline]
13899    fn bitor(self, rhs: Self) -> Self {
13900        Self(self.0 | rhs.0)
13901    }
13902}
13903impl core::ops::BitOrAssign for PhysicalDeviceSchedulingControlsFlagBitsARM {
13904    #[inline]
13905    fn bitor_assign(&mut self, rhs: Self) {
13906        self.0 |= rhs.0;
13907    }
13908}
13909impl core::ops::BitAnd for PhysicalDeviceSchedulingControlsFlagBitsARM {
13910    type Output = Self;
13911    #[inline]
13912    fn bitand(self, rhs: Self) -> Self {
13913        Self(self.0 & rhs.0)
13914    }
13915}
13916impl core::ops::BitAndAssign for PhysicalDeviceSchedulingControlsFlagBitsARM {
13917    #[inline]
13918    fn bitand_assign(&mut self, rhs: Self) {
13919        self.0 &= rhs.0;
13920    }
13921}
13922impl core::ops::BitXor for PhysicalDeviceSchedulingControlsFlagBitsARM {
13923    type Output = Self;
13924    #[inline]
13925    fn bitxor(self, rhs: Self) -> Self {
13926        Self(self.0 ^ rhs.0)
13927    }
13928}
13929impl core::ops::BitXorAssign for PhysicalDeviceSchedulingControlsFlagBitsARM {
13930    #[inline]
13931    fn bitxor_assign(&mut self, rhs: Self) {
13932        self.0 ^= rhs.0;
13933    }
13934}
13935impl core::ops::Not for PhysicalDeviceSchedulingControlsFlagBitsARM {
13936    type Output = Self;
13937    #[inline]
13938    fn not(self) -> Self {
13939        Self(!self.0)
13940    }
13941}
13942impl core::fmt::Debug for PhysicalDeviceSchedulingControlsFlagBitsARM {
13943    #[allow(unused_mut, unused_variables)]
13944    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13945        let mut first = true;
13946        let mut remaining = self.0;
13947        if remaining & Self::SHADER_CORE_COUNT.0 != 0 {
13948            if !first {
13949                f.write_str(" | ")?;
13950            }
13951            f.write_str("SHADER_CORE_COUNT")?;
13952            remaining &= !Self::SHADER_CORE_COUNT.0;
13953            first = false;
13954        }
13955        if remaining != 0u64 {
13956            if !first {
13957                f.write_str(" | ")?;
13958            }
13959            write!(f, "{:#x}", remaining)?;
13960        } else if first {
13961            f.write_str("(empty)")?;
13962        }
13963        Ok(())
13964    }
13965}
13966///[`VkPipelineCacheCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheCreateFlagBits.html)
13967#[repr(transparent)]
13968#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
13969#[doc(alias = "VkPipelineCacheCreateFlagBits")]
13970pub struct PipelineCacheCreateFlagBits(u32);
13971impl PipelineCacheCreateFlagBits {
13972    #[inline]
13973    pub const fn empty() -> Self {
13974        Self(0u32)
13975    }
13976    #[inline]
13977    pub const fn from_raw(value: u32) -> Self {
13978        Self(value)
13979    }
13980    #[inline]
13981    pub const fn as_raw(self) -> u32 {
13982        self.0
13983    }
13984    #[inline]
13985    pub const fn is_empty(self) -> bool {
13986        self.0 == 0u32
13987    }
13988    #[inline]
13989    pub const fn contains(self, other: Self) -> bool {
13990        (self.0 & other.0) == other.0
13991    }
13992    #[inline]
13993    pub const fn all() -> Self {
13994        Self(15u32)
13995    }
13996    ///Bit 0.
13997    pub const EXTERNALLY_SYNCHRONIZED: Self = Self(1u32);
13998    ///Bit 1.
13999    pub const READ_ONLY: Self = Self(2u32);
14000    ///Bit 2.
14001    pub const USE_APPLICATION_STORAGE: Self = Self(4u32);
14002    ///Bit 3.
14003    pub const INTERNALLY_SYNCHRONIZED_MERGE: Self = Self(8u32);
14004}
14005impl core::ops::BitOr for PipelineCacheCreateFlagBits {
14006    type Output = Self;
14007    #[inline]
14008    fn bitor(self, rhs: Self) -> Self {
14009        Self(self.0 | rhs.0)
14010    }
14011}
14012impl core::ops::BitOrAssign for PipelineCacheCreateFlagBits {
14013    #[inline]
14014    fn bitor_assign(&mut self, rhs: Self) {
14015        self.0 |= rhs.0;
14016    }
14017}
14018impl core::ops::BitAnd for PipelineCacheCreateFlagBits {
14019    type Output = Self;
14020    #[inline]
14021    fn bitand(self, rhs: Self) -> Self {
14022        Self(self.0 & rhs.0)
14023    }
14024}
14025impl core::ops::BitAndAssign for PipelineCacheCreateFlagBits {
14026    #[inline]
14027    fn bitand_assign(&mut self, rhs: Self) {
14028        self.0 &= rhs.0;
14029    }
14030}
14031impl core::ops::BitXor for PipelineCacheCreateFlagBits {
14032    type Output = Self;
14033    #[inline]
14034    fn bitxor(self, rhs: Self) -> Self {
14035        Self(self.0 ^ rhs.0)
14036    }
14037}
14038impl core::ops::BitXorAssign for PipelineCacheCreateFlagBits {
14039    #[inline]
14040    fn bitxor_assign(&mut self, rhs: Self) {
14041        self.0 ^= rhs.0;
14042    }
14043}
14044impl core::ops::Not for PipelineCacheCreateFlagBits {
14045    type Output = Self;
14046    #[inline]
14047    fn not(self) -> Self {
14048        Self(!self.0)
14049    }
14050}
14051impl core::fmt::Debug for PipelineCacheCreateFlagBits {
14052    #[allow(unused_mut, unused_variables)]
14053    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
14054        let mut first = true;
14055        let mut remaining = self.0;
14056        if remaining & Self::EXTERNALLY_SYNCHRONIZED.0 != 0 {
14057            if !first {
14058                f.write_str(" | ")?;
14059            }
14060            f.write_str("EXTERNALLY_SYNCHRONIZED")?;
14061            remaining &= !Self::EXTERNALLY_SYNCHRONIZED.0;
14062            first = false;
14063        }
14064        if remaining & Self::READ_ONLY.0 != 0 {
14065            if !first {
14066                f.write_str(" | ")?;
14067            }
14068            f.write_str("READ_ONLY")?;
14069            remaining &= !Self::READ_ONLY.0;
14070            first = false;
14071        }
14072        if remaining & Self::USE_APPLICATION_STORAGE.0 != 0 {
14073            if !first {
14074                f.write_str(" | ")?;
14075            }
14076            f.write_str("USE_APPLICATION_STORAGE")?;
14077            remaining &= !Self::USE_APPLICATION_STORAGE.0;
14078            first = false;
14079        }
14080        if remaining & Self::INTERNALLY_SYNCHRONIZED_MERGE.0 != 0 {
14081            if !first {
14082                f.write_str(" | ")?;
14083            }
14084            f.write_str("INTERNALLY_SYNCHRONIZED_MERGE")?;
14085            remaining &= !Self::INTERNALLY_SYNCHRONIZED_MERGE.0;
14086            first = false;
14087        }
14088        if remaining != 0u32 {
14089            if !first {
14090                f.write_str(" | ")?;
14091            }
14092            write!(f, "{:#x}", remaining)?;
14093        } else if first {
14094            f.write_str("(empty)")?;
14095        }
14096        Ok(())
14097    }
14098}
14099///[`VkPipelineColorBlendStateCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateFlagBits.html)
14100#[repr(transparent)]
14101#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
14102#[doc(alias = "VkPipelineColorBlendStateCreateFlagBits")]
14103pub struct PipelineColorBlendStateCreateFlagBits(u32);
14104impl PipelineColorBlendStateCreateFlagBits {
14105    #[inline]
14106    pub const fn empty() -> Self {
14107        Self(0u32)
14108    }
14109    #[inline]
14110    pub const fn from_raw(value: u32) -> Self {
14111        Self(value)
14112    }
14113    #[inline]
14114    pub const fn as_raw(self) -> u32 {
14115        self.0
14116    }
14117    #[inline]
14118    pub const fn is_empty(self) -> bool {
14119        self.0 == 0u32
14120    }
14121    #[inline]
14122    pub const fn contains(self, other: Self) -> bool {
14123        (self.0 & other.0) == other.0
14124    }
14125    #[inline]
14126    pub const fn all() -> Self {
14127        Self(1u32)
14128    }
14129    pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS;
14130    ///Bit 0.
14131    pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS: Self = Self(1u32);
14132}
14133impl core::ops::BitOr for PipelineColorBlendStateCreateFlagBits {
14134    type Output = Self;
14135    #[inline]
14136    fn bitor(self, rhs: Self) -> Self {
14137        Self(self.0 | rhs.0)
14138    }
14139}
14140impl core::ops::BitOrAssign for PipelineColorBlendStateCreateFlagBits {
14141    #[inline]
14142    fn bitor_assign(&mut self, rhs: Self) {
14143        self.0 |= rhs.0;
14144    }
14145}
14146impl core::ops::BitAnd for PipelineColorBlendStateCreateFlagBits {
14147    type Output = Self;
14148    #[inline]
14149    fn bitand(self, rhs: Self) -> Self {
14150        Self(self.0 & rhs.0)
14151    }
14152}
14153impl core::ops::BitAndAssign for PipelineColorBlendStateCreateFlagBits {
14154    #[inline]
14155    fn bitand_assign(&mut self, rhs: Self) {
14156        self.0 &= rhs.0;
14157    }
14158}
14159impl core::ops::BitXor for PipelineColorBlendStateCreateFlagBits {
14160    type Output = Self;
14161    #[inline]
14162    fn bitxor(self, rhs: Self) -> Self {
14163        Self(self.0 ^ rhs.0)
14164    }
14165}
14166impl core::ops::BitXorAssign for PipelineColorBlendStateCreateFlagBits {
14167    #[inline]
14168    fn bitxor_assign(&mut self, rhs: Self) {
14169        self.0 ^= rhs.0;
14170    }
14171}
14172impl core::ops::Not for PipelineColorBlendStateCreateFlagBits {
14173    type Output = Self;
14174    #[inline]
14175    fn not(self) -> Self {
14176        Self(!self.0)
14177    }
14178}
14179impl core::fmt::Debug for PipelineColorBlendStateCreateFlagBits {
14180    #[allow(unused_mut, unused_variables)]
14181    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
14182        let mut first = true;
14183        let mut remaining = self.0;
14184        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS.0 != 0 {
14185            if !first {
14186                f.write_str(" | ")?;
14187            }
14188            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_ACCESS")?;
14189            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS.0;
14190            first = false;
14191        }
14192        if remaining != 0u32 {
14193            if !first {
14194                f.write_str(" | ")?;
14195            }
14196            write!(f, "{:#x}", remaining)?;
14197        } else if first {
14198            f.write_str("(empty)")?;
14199        }
14200        Ok(())
14201    }
14202}
14203///[`VkPipelineCompilerControlFlagBitsAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCompilerControlFlagBitsAMD.html)
14204#[repr(transparent)]
14205#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
14206#[doc(alias = "VkPipelineCompilerControlFlagBitsAMD")]
14207pub struct PipelineCompilerControlFlagBitsAMD(u32);
14208impl PipelineCompilerControlFlagBitsAMD {
14209    #[inline]
14210    pub const fn empty() -> Self {
14211        Self(0u32)
14212    }
14213    #[inline]
14214    pub const fn from_raw(value: u32) -> Self {
14215        Self(value)
14216    }
14217    #[inline]
14218    pub const fn as_raw(self) -> u32 {
14219        self.0
14220    }
14221    #[inline]
14222    pub const fn is_empty(self) -> bool {
14223        self.0 == 0u32
14224    }
14225    #[inline]
14226    pub const fn contains(self, other: Self) -> bool {
14227        (self.0 & other.0) == other.0
14228    }
14229    #[inline]
14230    pub const fn all() -> Self {
14231        Self(0u32)
14232    }
14233}
14234impl core::ops::BitOr for PipelineCompilerControlFlagBitsAMD {
14235    type Output = Self;
14236    #[inline]
14237    fn bitor(self, rhs: Self) -> Self {
14238        Self(self.0 | rhs.0)
14239    }
14240}
14241impl core::ops::BitOrAssign for PipelineCompilerControlFlagBitsAMD {
14242    #[inline]
14243    fn bitor_assign(&mut self, rhs: Self) {
14244        self.0 |= rhs.0;
14245    }
14246}
14247impl core::ops::BitAnd for PipelineCompilerControlFlagBitsAMD {
14248    type Output = Self;
14249    #[inline]
14250    fn bitand(self, rhs: Self) -> Self {
14251        Self(self.0 & rhs.0)
14252    }
14253}
14254impl core::ops::BitAndAssign for PipelineCompilerControlFlagBitsAMD {
14255    #[inline]
14256    fn bitand_assign(&mut self, rhs: Self) {
14257        self.0 &= rhs.0;
14258    }
14259}
14260impl core::ops::BitXor for PipelineCompilerControlFlagBitsAMD {
14261    type Output = Self;
14262    #[inline]
14263    fn bitxor(self, rhs: Self) -> Self {
14264        Self(self.0 ^ rhs.0)
14265    }
14266}
14267impl core::ops::BitXorAssign for PipelineCompilerControlFlagBitsAMD {
14268    #[inline]
14269    fn bitxor_assign(&mut self, rhs: Self) {
14270        self.0 ^= rhs.0;
14271    }
14272}
14273impl core::ops::Not for PipelineCompilerControlFlagBitsAMD {
14274    type Output = Self;
14275    #[inline]
14276    fn not(self) -> Self {
14277        Self(!self.0)
14278    }
14279}
14280impl core::fmt::Debug for PipelineCompilerControlFlagBitsAMD {
14281    #[allow(unused_mut, unused_variables)]
14282    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
14283        let mut first = true;
14284        let mut remaining = self.0;
14285        if remaining != 0u32 {
14286            if !first {
14287                f.write_str(" | ")?;
14288            }
14289            write!(f, "{:#x}", remaining)?;
14290        } else if first {
14291            f.write_str("(empty)")?;
14292        }
14293        Ok(())
14294    }
14295}
14296///[`VkPipelineCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits.html)
14297#[repr(transparent)]
14298#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
14299#[doc(alias = "VkPipelineCreateFlagBits")]
14300pub struct PipelineCreateFlagBits(u32);
14301impl PipelineCreateFlagBits {
14302    #[inline]
14303    pub const fn empty() -> Self {
14304        Self(0u32)
14305    }
14306    #[inline]
14307    pub const fn from_raw(value: u32) -> Self {
14308        Self(value)
14309    }
14310    #[inline]
14311    pub const fn as_raw(self) -> u32 {
14312        self.0
14313    }
14314    #[inline]
14315    pub const fn is_empty(self) -> bool {
14316        self.0 == 0u32
14317    }
14318    #[inline]
14319    pub const fn contains(self, other: Self) -> bool {
14320        (self.0 & other.0) == other.0
14321    }
14322    #[inline]
14323    pub const fn all() -> Self {
14324        Self(2147483647u32)
14325    }
14326    ///Bit 0.
14327    pub const DISABLE_OPTIMIZATION: Self = Self(1u32);
14328    ///Bit 1.
14329    pub const ALLOW_DERIVATIVES: Self = Self(2u32);
14330    ///Bit 2.
14331    pub const DERIVATIVE: Self = Self(4u32);
14332    ///Bit 4.
14333    pub const DISPATCH_BASE: Self = Self(16u32);
14334    ///Bit 3.
14335    pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(8u32);
14336    ///Bit 8.
14337    pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(256u32);
14338    ///Bit 9.
14339    pub const EARLY_RETURN_ON_FAILURE: Self = Self(512u32);
14340    ///Bit 27.
14341    pub const NO_PROTECTED_ACCESS: Self = Self(134217728u32);
14342    ///Bit 30.
14343    pub const PROTECTED_ACCESS_ONLY: Self = Self(1073741824u32);
14344    ///Bit 14.
14345    pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS: Self = Self(16384u32);
14346    ///Bit 15.
14347    pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS: Self = Self(32768u32);
14348    ///Bit 16.
14349    pub const RAY_TRACING_NO_NULL_MISS_SHADERS: Self = Self(65536u32);
14350    ///Bit 17.
14351    pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS: Self = Self(131072u32);
14352    ///Bit 12.
14353    pub const RAY_TRACING_SKIP_TRIANGLES: Self = Self(4096u32);
14354    ///Bit 13.
14355    pub const RAY_TRACING_SKIP_AABBS: Self = Self(8192u32);
14356    ///Bit 19.
14357    pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY: Self = Self(524288u32);
14358    ///Bit 5.
14359    pub const DEFER_COMPILE: Self = Self(32u32);
14360    ///Bit 22.
14361    pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(4194304u32);
14362    pub const PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT;
14363    ///Bit 21.
14364    pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(2097152u32);
14365    pub const PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT;
14366    ///Bit 6.
14367    pub const CAPTURE_STATISTICS: Self = Self(64u32);
14368    ///Bit 7.
14369    pub const CAPTURE_INTERNAL_REPRESENTATIONS: Self = Self(128u32);
14370    ///Bit 18.
14371    pub const INDIRECT_BINDABLE: Self = Self(262144u32);
14372    ///Bit 11.
14373    pub const LIBRARY: Self = Self(2048u32);
14374    ///Bit 29.
14375    pub const DESCRIPTOR_BUFFER: Self = Self(536870912u32);
14376    ///Bit 23.
14377    pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO: Self = Self(8388608u32);
14378    ///Bit 10.
14379    pub const LINK_TIME_OPTIMIZATION: Self = Self(1024u32);
14380    ///Bit 20.
14381    pub const RAY_TRACING_ALLOW_MOTION: Self = Self(1048576u32);
14382    ///Bit 25.
14383    pub const COLOR_ATTACHMENT_FEEDBACK_LOOP: Self = Self(33554432u32);
14384    ///Bit 26.
14385    pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP: Self = Self(67108864u32);
14386    ///Bit 24.
14387    pub const RAY_TRACING_OPACITY_MICROMAP: Self = Self(16777216u32);
14388    ///Bit 28.
14389    pub const RAY_TRACING_DISPLACEMENT_MICROMAP: Self = Self(268435456u32);
14390}
14391impl core::ops::BitOr for PipelineCreateFlagBits {
14392    type Output = Self;
14393    #[inline]
14394    fn bitor(self, rhs: Self) -> Self {
14395        Self(self.0 | rhs.0)
14396    }
14397}
14398impl core::ops::BitOrAssign for PipelineCreateFlagBits {
14399    #[inline]
14400    fn bitor_assign(&mut self, rhs: Self) {
14401        self.0 |= rhs.0;
14402    }
14403}
14404impl core::ops::BitAnd for PipelineCreateFlagBits {
14405    type Output = Self;
14406    #[inline]
14407    fn bitand(self, rhs: Self) -> Self {
14408        Self(self.0 & rhs.0)
14409    }
14410}
14411impl core::ops::BitAndAssign for PipelineCreateFlagBits {
14412    #[inline]
14413    fn bitand_assign(&mut self, rhs: Self) {
14414        self.0 &= rhs.0;
14415    }
14416}
14417impl core::ops::BitXor for PipelineCreateFlagBits {
14418    type Output = Self;
14419    #[inline]
14420    fn bitxor(self, rhs: Self) -> Self {
14421        Self(self.0 ^ rhs.0)
14422    }
14423}
14424impl core::ops::BitXorAssign for PipelineCreateFlagBits {
14425    #[inline]
14426    fn bitxor_assign(&mut self, rhs: Self) {
14427        self.0 ^= rhs.0;
14428    }
14429}
14430impl core::ops::Not for PipelineCreateFlagBits {
14431    type Output = Self;
14432    #[inline]
14433    fn not(self) -> Self {
14434        Self(!self.0)
14435    }
14436}
14437impl core::fmt::Debug for PipelineCreateFlagBits {
14438    #[allow(unused_mut, unused_variables)]
14439    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
14440        let mut first = true;
14441        let mut remaining = self.0;
14442        if remaining & Self::DISABLE_OPTIMIZATION.0 != 0 {
14443            if !first {
14444                f.write_str(" | ")?;
14445            }
14446            f.write_str("DISABLE_OPTIMIZATION")?;
14447            remaining &= !Self::DISABLE_OPTIMIZATION.0;
14448            first = false;
14449        }
14450        if remaining & Self::ALLOW_DERIVATIVES.0 != 0 {
14451            if !first {
14452                f.write_str(" | ")?;
14453            }
14454            f.write_str("ALLOW_DERIVATIVES")?;
14455            remaining &= !Self::ALLOW_DERIVATIVES.0;
14456            first = false;
14457        }
14458        if remaining & Self::DERIVATIVE.0 != 0 {
14459            if !first {
14460                f.write_str(" | ")?;
14461            }
14462            f.write_str("DERIVATIVE")?;
14463            remaining &= !Self::DERIVATIVE.0;
14464            first = false;
14465        }
14466        if remaining & Self::DISPATCH_BASE.0 != 0 {
14467            if !first {
14468                f.write_str(" | ")?;
14469            }
14470            f.write_str("DISPATCH_BASE")?;
14471            remaining &= !Self::DISPATCH_BASE.0;
14472            first = false;
14473        }
14474        if remaining & Self::VIEW_INDEX_FROM_DEVICE_INDEX.0 != 0 {
14475            if !first {
14476                f.write_str(" | ")?;
14477            }
14478            f.write_str("VIEW_INDEX_FROM_DEVICE_INDEX")?;
14479            remaining &= !Self::VIEW_INDEX_FROM_DEVICE_INDEX.0;
14480            first = false;
14481        }
14482        if remaining & Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0 != 0 {
14483            if !first {
14484                f.write_str(" | ")?;
14485            }
14486            f.write_str("FAIL_ON_PIPELINE_COMPILE_REQUIRED")?;
14487            remaining &= !Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0;
14488            first = false;
14489        }
14490        if remaining & Self::EARLY_RETURN_ON_FAILURE.0 != 0 {
14491            if !first {
14492                f.write_str(" | ")?;
14493            }
14494            f.write_str("EARLY_RETURN_ON_FAILURE")?;
14495            remaining &= !Self::EARLY_RETURN_ON_FAILURE.0;
14496            first = false;
14497        }
14498        if remaining & Self::NO_PROTECTED_ACCESS.0 != 0 {
14499            if !first {
14500                f.write_str(" | ")?;
14501            }
14502            f.write_str("NO_PROTECTED_ACCESS")?;
14503            remaining &= !Self::NO_PROTECTED_ACCESS.0;
14504            first = false;
14505        }
14506        if remaining & Self::PROTECTED_ACCESS_ONLY.0 != 0 {
14507            if !first {
14508                f.write_str(" | ")?;
14509            }
14510            f.write_str("PROTECTED_ACCESS_ONLY")?;
14511            remaining &= !Self::PROTECTED_ACCESS_ONLY.0;
14512            first = false;
14513        }
14514        if remaining & Self::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0 != 0 {
14515            if !first {
14516                f.write_str(" | ")?;
14517            }
14518            f.write_str("RAY_TRACING_NO_NULL_ANY_HIT_SHADERS")?;
14519            remaining &= !Self::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0;
14520            first = false;
14521        }
14522        if remaining & Self::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0 != 0 {
14523            if !first {
14524                f.write_str(" | ")?;
14525            }
14526            f.write_str("RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS")?;
14527            remaining &= !Self::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0;
14528            first = false;
14529        }
14530        if remaining & Self::RAY_TRACING_NO_NULL_MISS_SHADERS.0 != 0 {
14531            if !first {
14532                f.write_str(" | ")?;
14533            }
14534            f.write_str("RAY_TRACING_NO_NULL_MISS_SHADERS")?;
14535            remaining &= !Self::RAY_TRACING_NO_NULL_MISS_SHADERS.0;
14536            first = false;
14537        }
14538        if remaining & Self::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0 != 0 {
14539            if !first {
14540                f.write_str(" | ")?;
14541            }
14542            f.write_str("RAY_TRACING_NO_NULL_INTERSECTION_SHADERS")?;
14543            remaining &= !Self::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0;
14544            first = false;
14545        }
14546        if remaining & Self::RAY_TRACING_SKIP_TRIANGLES.0 != 0 {
14547            if !first {
14548                f.write_str(" | ")?;
14549            }
14550            f.write_str("RAY_TRACING_SKIP_TRIANGLES")?;
14551            remaining &= !Self::RAY_TRACING_SKIP_TRIANGLES.0;
14552            first = false;
14553        }
14554        if remaining & Self::RAY_TRACING_SKIP_AABBS.0 != 0 {
14555            if !first {
14556                f.write_str(" | ")?;
14557            }
14558            f.write_str("RAY_TRACING_SKIP_AABBS")?;
14559            remaining &= !Self::RAY_TRACING_SKIP_AABBS.0;
14560            first = false;
14561        }
14562        if remaining & Self::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0 != 0 {
14563            if !first {
14564                f.write_str(" | ")?;
14565            }
14566            f.write_str("RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY")?;
14567            remaining &= !Self::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0;
14568            first = false;
14569        }
14570        if remaining & Self::DEFER_COMPILE.0 != 0 {
14571            if !first {
14572                f.write_str(" | ")?;
14573            }
14574            f.write_str("DEFER_COMPILE")?;
14575            remaining &= !Self::DEFER_COMPILE.0;
14576            first = false;
14577        }
14578        if remaining & Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0 != 0 {
14579            if !first {
14580                f.write_str(" | ")?;
14581            }
14582            f.write_str("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT")?;
14583            remaining &= !Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0;
14584            first = false;
14585        }
14586        if remaining & Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
14587            if !first {
14588                f.write_str(" | ")?;
14589            }
14590            f.write_str("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT")?;
14591            remaining &= !Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0;
14592            first = false;
14593        }
14594        if remaining & Self::CAPTURE_STATISTICS.0 != 0 {
14595            if !first {
14596                f.write_str(" | ")?;
14597            }
14598            f.write_str("CAPTURE_STATISTICS")?;
14599            remaining &= !Self::CAPTURE_STATISTICS.0;
14600            first = false;
14601        }
14602        if remaining & Self::CAPTURE_INTERNAL_REPRESENTATIONS.0 != 0 {
14603            if !first {
14604                f.write_str(" | ")?;
14605            }
14606            f.write_str("CAPTURE_INTERNAL_REPRESENTATIONS")?;
14607            remaining &= !Self::CAPTURE_INTERNAL_REPRESENTATIONS.0;
14608            first = false;
14609        }
14610        if remaining & Self::INDIRECT_BINDABLE.0 != 0 {
14611            if !first {
14612                f.write_str(" | ")?;
14613            }
14614            f.write_str("INDIRECT_BINDABLE")?;
14615            remaining &= !Self::INDIRECT_BINDABLE.0;
14616            first = false;
14617        }
14618        if remaining & Self::LIBRARY.0 != 0 {
14619            if !first {
14620                f.write_str(" | ")?;
14621            }
14622            f.write_str("LIBRARY")?;
14623            remaining &= !Self::LIBRARY.0;
14624            first = false;
14625        }
14626        if remaining & Self::DESCRIPTOR_BUFFER.0 != 0 {
14627            if !first {
14628                f.write_str(" | ")?;
14629            }
14630            f.write_str("DESCRIPTOR_BUFFER")?;
14631            remaining &= !Self::DESCRIPTOR_BUFFER.0;
14632            first = false;
14633        }
14634        if remaining & Self::RETAIN_LINK_TIME_OPTIMIZATION_INFO.0 != 0 {
14635            if !first {
14636                f.write_str(" | ")?;
14637            }
14638            f.write_str("RETAIN_LINK_TIME_OPTIMIZATION_INFO")?;
14639            remaining &= !Self::RETAIN_LINK_TIME_OPTIMIZATION_INFO.0;
14640            first = false;
14641        }
14642        if remaining & Self::LINK_TIME_OPTIMIZATION.0 != 0 {
14643            if !first {
14644                f.write_str(" | ")?;
14645            }
14646            f.write_str("LINK_TIME_OPTIMIZATION")?;
14647            remaining &= !Self::LINK_TIME_OPTIMIZATION.0;
14648            first = false;
14649        }
14650        if remaining & Self::RAY_TRACING_ALLOW_MOTION.0 != 0 {
14651            if !first {
14652                f.write_str(" | ")?;
14653            }
14654            f.write_str("RAY_TRACING_ALLOW_MOTION")?;
14655            remaining &= !Self::RAY_TRACING_ALLOW_MOTION.0;
14656            first = false;
14657        }
14658        if remaining & Self::COLOR_ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
14659            if !first {
14660                f.write_str(" | ")?;
14661            }
14662            f.write_str("COLOR_ATTACHMENT_FEEDBACK_LOOP")?;
14663            remaining &= !Self::COLOR_ATTACHMENT_FEEDBACK_LOOP.0;
14664            first = false;
14665        }
14666        if remaining & Self::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
14667            if !first {
14668                f.write_str(" | ")?;
14669            }
14670            f.write_str("DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP")?;
14671            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0;
14672            first = false;
14673        }
14674        if remaining & Self::RAY_TRACING_OPACITY_MICROMAP.0 != 0 {
14675            if !first {
14676                f.write_str(" | ")?;
14677            }
14678            f.write_str("RAY_TRACING_OPACITY_MICROMAP")?;
14679            remaining &= !Self::RAY_TRACING_OPACITY_MICROMAP.0;
14680            first = false;
14681        }
14682        if remaining & Self::RAY_TRACING_DISPLACEMENT_MICROMAP.0 != 0 {
14683            if !first {
14684                f.write_str(" | ")?;
14685            }
14686            f.write_str("RAY_TRACING_DISPLACEMENT_MICROMAP")?;
14687            remaining &= !Self::RAY_TRACING_DISPLACEMENT_MICROMAP.0;
14688            first = false;
14689        }
14690        if remaining != 0u32 {
14691            if !first {
14692                f.write_str(" | ")?;
14693            }
14694            write!(f, "{:#x}", remaining)?;
14695        } else if first {
14696            f.write_str("(empty)")?;
14697        }
14698        Ok(())
14699    }
14700}
14701///[`VkPipelineCreateFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits2.html)
14702#[repr(transparent)]
14703#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
14704#[doc(alias = "VkPipelineCreateFlagBits2")]
14705pub struct PipelineCreateFlagBits2(u64);
14706impl PipelineCreateFlagBits2 {
14707    #[inline]
14708    pub const fn empty() -> Self {
14709        Self(0u64)
14710    }
14711    #[inline]
14712    pub const fn from_raw(value: u64) -> Self {
14713        Self(value)
14714    }
14715    #[inline]
14716    pub const fn as_raw(self) -> u64 {
14717        self.0
14718    }
14719    #[inline]
14720    pub const fn is_empty(self) -> bool {
14721        self.0 == 0u64
14722    }
14723    #[inline]
14724    pub const fn contains(self, other: Self) -> bool {
14725        (self.0 & other.0) == other.0
14726    }
14727    #[inline]
14728    pub const fn all() -> Self {
14729        Self(10685878632447u64)
14730    }
14731    ///Bit 0.
14732    pub const _2_DISABLE_OPTIMIZATION: Self = Self(1u64);
14733    ///Bit 1.
14734    pub const _2_ALLOW_DERIVATIVES: Self = Self(2u64);
14735    ///Bit 2.
14736    pub const _2_DERIVATIVE: Self = Self(4u64);
14737    ///Bit 3.
14738    pub const _2_VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(8u64);
14739    ///Bit 4.
14740    pub const _2_DISPATCH_BASE: Self = Self(16u64);
14741    ///Bit 8.
14742    pub const _2_FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(256u64);
14743    ///Bit 9.
14744    pub const _2_EARLY_RETURN_ON_FAILURE: Self = Self(512u64);
14745    ///Bit 27.
14746    pub const _2_NO_PROTECTED_ACCESS: Self = Self(134217728u64);
14747    ///Bit 30.
14748    pub const _2_PROTECTED_ACCESS_ONLY: Self = Self(1073741824u64);
14749    ///Bit 32.
14750    pub const _2_EXECUTION_GRAPH_BIT: Self = Self(4294967296u64);
14751    ///Bit 36.
14752    pub const _2_DESCRIPTOR_HEAP: Self = Self(68719476736u64);
14753    pub const _2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES: Self = Self::_2_RAY_TRACING_SKIP_TRIANGLES;
14754    ///Bit 33.
14755    pub const _2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES: Self = Self(
14756        8589934592u64,
14757    );
14758    ///Bit 34.
14759    pub const _2_ENABLE_LEGACY_DITHERING: Self = Self(17179869184u64);
14760    ///Bit 5.
14761    pub const _2_DEFER_COMPILE: Self = Self(32u64);
14762    ///Bit 6.
14763    pub const _2_CAPTURE_STATISTICS: Self = Self(64u64);
14764    ///Bit 7.
14765    pub const _2_CAPTURE_INTERNAL_REPRESENTATIONS: Self = Self(128u64);
14766    ///Bit 10.
14767    pub const _2_LINK_TIME_OPTIMIZATION: Self = Self(1024u64);
14768    ///Bit 23.
14769    pub const _2_RETAIN_LINK_TIME_OPTIMIZATION_INFO: Self = Self(8388608u64);
14770    ///Bit 11.
14771    pub const _2_LIBRARY: Self = Self(2048u64);
14772    ///Bit 12.
14773    pub const _2_RAY_TRACING_SKIP_TRIANGLES: Self = Self(4096u64);
14774    ///Bit 13.
14775    pub const _2_RAY_TRACING_SKIP_AABBS: Self = Self(8192u64);
14776    ///Bit 14.
14777    pub const _2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS: Self = Self(16384u64);
14778    ///Bit 15.
14779    pub const _2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS: Self = Self(32768u64);
14780    ///Bit 16.
14781    pub const _2_RAY_TRACING_NO_NULL_MISS_SHADERS: Self = Self(65536u64);
14782    ///Bit 17.
14783    pub const _2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS: Self = Self(131072u64);
14784    ///Bit 19.
14785    pub const _2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY: Self = Self(524288u64);
14786    ///Bit 18.
14787    pub const _2_INDIRECT_BINDABLE: Self = Self(262144u64);
14788    ///Bit 20.
14789    pub const _2_RAY_TRACING_ALLOW_MOTION: Self = Self(1048576u64);
14790    ///Bit 21.
14791    pub const _2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(2097152u64);
14792    ///Bit 22.
14793    pub const _2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(4194304u64);
14794    ///Bit 24.
14795    pub const _2_RAY_TRACING_OPACITY_MICROMAP: Self = Self(16777216u64);
14796    ///Bit 25.
14797    pub const _2_COLOR_ATTACHMENT_FEEDBACK_LOOP: Self = Self(33554432u64);
14798    ///Bit 26.
14799    pub const _2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP: Self = Self(67108864u64);
14800    ///Bit 28.
14801    pub const _2_RAY_TRACING_DISPLACEMENT_MICROMAP: Self = Self(268435456u64);
14802    ///Bit 29.
14803    pub const _2_DESCRIPTOR_BUFFER: Self = Self(536870912u64);
14804    ///Bit 37.
14805    pub const _2_DISALLOW_OPACITY_MICROMAP_BIT: Self = Self(137438953472u64);
14806    ///Bit 39.
14807    pub const _2_INSTRUMENT_SHADERS_BIT: Self = Self(549755813888u64);
14808    ///Bit 31.
14809    pub const _2_CAPTURE_DATA: Self = Self(2147483648u64);
14810    ///Bit 40.
14811    pub const _2_PER_LAYER_FRAGMENT_DENSITY_BIT: Self = Self(1099511627776u64);
14812    ///Bit 43.
14813    pub const _2_64_BIT_INDEXING: Self = Self(8796093022208u64);
14814}
14815impl core::ops::BitOr for PipelineCreateFlagBits2 {
14816    type Output = Self;
14817    #[inline]
14818    fn bitor(self, rhs: Self) -> Self {
14819        Self(self.0 | rhs.0)
14820    }
14821}
14822impl core::ops::BitOrAssign for PipelineCreateFlagBits2 {
14823    #[inline]
14824    fn bitor_assign(&mut self, rhs: Self) {
14825        self.0 |= rhs.0;
14826    }
14827}
14828impl core::ops::BitAnd for PipelineCreateFlagBits2 {
14829    type Output = Self;
14830    #[inline]
14831    fn bitand(self, rhs: Self) -> Self {
14832        Self(self.0 & rhs.0)
14833    }
14834}
14835impl core::ops::BitAndAssign for PipelineCreateFlagBits2 {
14836    #[inline]
14837    fn bitand_assign(&mut self, rhs: Self) {
14838        self.0 &= rhs.0;
14839    }
14840}
14841impl core::ops::BitXor for PipelineCreateFlagBits2 {
14842    type Output = Self;
14843    #[inline]
14844    fn bitxor(self, rhs: Self) -> Self {
14845        Self(self.0 ^ rhs.0)
14846    }
14847}
14848impl core::ops::BitXorAssign for PipelineCreateFlagBits2 {
14849    #[inline]
14850    fn bitxor_assign(&mut self, rhs: Self) {
14851        self.0 ^= rhs.0;
14852    }
14853}
14854impl core::ops::Not for PipelineCreateFlagBits2 {
14855    type Output = Self;
14856    #[inline]
14857    fn not(self) -> Self {
14858        Self(!self.0)
14859    }
14860}
14861impl core::fmt::Debug for PipelineCreateFlagBits2 {
14862    #[allow(unused_mut, unused_variables)]
14863    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
14864        let mut first = true;
14865        let mut remaining = self.0;
14866        if remaining & Self::_2_DISABLE_OPTIMIZATION.0 != 0 {
14867            if !first {
14868                f.write_str(" | ")?;
14869            }
14870            f.write_str("_2_DISABLE_OPTIMIZATION")?;
14871            remaining &= !Self::_2_DISABLE_OPTIMIZATION.0;
14872            first = false;
14873        }
14874        if remaining & Self::_2_ALLOW_DERIVATIVES.0 != 0 {
14875            if !first {
14876                f.write_str(" | ")?;
14877            }
14878            f.write_str("_2_ALLOW_DERIVATIVES")?;
14879            remaining &= !Self::_2_ALLOW_DERIVATIVES.0;
14880            first = false;
14881        }
14882        if remaining & Self::_2_DERIVATIVE.0 != 0 {
14883            if !first {
14884                f.write_str(" | ")?;
14885            }
14886            f.write_str("_2_DERIVATIVE")?;
14887            remaining &= !Self::_2_DERIVATIVE.0;
14888            first = false;
14889        }
14890        if remaining & Self::_2_VIEW_INDEX_FROM_DEVICE_INDEX.0 != 0 {
14891            if !first {
14892                f.write_str(" | ")?;
14893            }
14894            f.write_str("_2_VIEW_INDEX_FROM_DEVICE_INDEX")?;
14895            remaining &= !Self::_2_VIEW_INDEX_FROM_DEVICE_INDEX.0;
14896            first = false;
14897        }
14898        if remaining & Self::_2_DISPATCH_BASE.0 != 0 {
14899            if !first {
14900                f.write_str(" | ")?;
14901            }
14902            f.write_str("_2_DISPATCH_BASE")?;
14903            remaining &= !Self::_2_DISPATCH_BASE.0;
14904            first = false;
14905        }
14906        if remaining & Self::_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED.0 != 0 {
14907            if !first {
14908                f.write_str(" | ")?;
14909            }
14910            f.write_str("_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED")?;
14911            remaining &= !Self::_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED.0;
14912            first = false;
14913        }
14914        if remaining & Self::_2_EARLY_RETURN_ON_FAILURE.0 != 0 {
14915            if !first {
14916                f.write_str(" | ")?;
14917            }
14918            f.write_str("_2_EARLY_RETURN_ON_FAILURE")?;
14919            remaining &= !Self::_2_EARLY_RETURN_ON_FAILURE.0;
14920            first = false;
14921        }
14922        if remaining & Self::_2_NO_PROTECTED_ACCESS.0 != 0 {
14923            if !first {
14924                f.write_str(" | ")?;
14925            }
14926            f.write_str("_2_NO_PROTECTED_ACCESS")?;
14927            remaining &= !Self::_2_NO_PROTECTED_ACCESS.0;
14928            first = false;
14929        }
14930        if remaining & Self::_2_PROTECTED_ACCESS_ONLY.0 != 0 {
14931            if !first {
14932                f.write_str(" | ")?;
14933            }
14934            f.write_str("_2_PROTECTED_ACCESS_ONLY")?;
14935            remaining &= !Self::_2_PROTECTED_ACCESS_ONLY.0;
14936            first = false;
14937        }
14938        if remaining & Self::_2_EXECUTION_GRAPH_BIT.0 != 0 {
14939            if !first {
14940                f.write_str(" | ")?;
14941            }
14942            f.write_str("_2_EXECUTION_GRAPH_BIT")?;
14943            remaining &= !Self::_2_EXECUTION_GRAPH_BIT.0;
14944            first = false;
14945        }
14946        if remaining & Self::_2_DESCRIPTOR_HEAP.0 != 0 {
14947            if !first {
14948                f.write_str(" | ")?;
14949            }
14950            f.write_str("_2_DESCRIPTOR_HEAP")?;
14951            remaining &= !Self::_2_DESCRIPTOR_HEAP.0;
14952            first = false;
14953        }
14954        if remaining & Self::_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES.0 != 0
14955        {
14956            if !first {
14957                f.write_str(" | ")?;
14958            }
14959            f.write_str("_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES")?;
14960            remaining &= !Self::_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES.0;
14961            first = false;
14962        }
14963        if remaining & Self::_2_ENABLE_LEGACY_DITHERING.0 != 0 {
14964            if !first {
14965                f.write_str(" | ")?;
14966            }
14967            f.write_str("_2_ENABLE_LEGACY_DITHERING")?;
14968            remaining &= !Self::_2_ENABLE_LEGACY_DITHERING.0;
14969            first = false;
14970        }
14971        if remaining & Self::_2_DEFER_COMPILE.0 != 0 {
14972            if !first {
14973                f.write_str(" | ")?;
14974            }
14975            f.write_str("_2_DEFER_COMPILE")?;
14976            remaining &= !Self::_2_DEFER_COMPILE.0;
14977            first = false;
14978        }
14979        if remaining & Self::_2_CAPTURE_STATISTICS.0 != 0 {
14980            if !first {
14981                f.write_str(" | ")?;
14982            }
14983            f.write_str("_2_CAPTURE_STATISTICS")?;
14984            remaining &= !Self::_2_CAPTURE_STATISTICS.0;
14985            first = false;
14986        }
14987        if remaining & Self::_2_CAPTURE_INTERNAL_REPRESENTATIONS.0 != 0 {
14988            if !first {
14989                f.write_str(" | ")?;
14990            }
14991            f.write_str("_2_CAPTURE_INTERNAL_REPRESENTATIONS")?;
14992            remaining &= !Self::_2_CAPTURE_INTERNAL_REPRESENTATIONS.0;
14993            first = false;
14994        }
14995        if remaining & Self::_2_LINK_TIME_OPTIMIZATION.0 != 0 {
14996            if !first {
14997                f.write_str(" | ")?;
14998            }
14999            f.write_str("_2_LINK_TIME_OPTIMIZATION")?;
15000            remaining &= !Self::_2_LINK_TIME_OPTIMIZATION.0;
15001            first = false;
15002        }
15003        if remaining & Self::_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO.0 != 0 {
15004            if !first {
15005                f.write_str(" | ")?;
15006            }
15007            f.write_str("_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO")?;
15008            remaining &= !Self::_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO.0;
15009            first = false;
15010        }
15011        if remaining & Self::_2_LIBRARY.0 != 0 {
15012            if !first {
15013                f.write_str(" | ")?;
15014            }
15015            f.write_str("_2_LIBRARY")?;
15016            remaining &= !Self::_2_LIBRARY.0;
15017            first = false;
15018        }
15019        if remaining & Self::_2_RAY_TRACING_SKIP_TRIANGLES.0 != 0 {
15020            if !first {
15021                f.write_str(" | ")?;
15022            }
15023            f.write_str("_2_RAY_TRACING_SKIP_TRIANGLES")?;
15024            remaining &= !Self::_2_RAY_TRACING_SKIP_TRIANGLES.0;
15025            first = false;
15026        }
15027        if remaining & Self::_2_RAY_TRACING_SKIP_AABBS.0 != 0 {
15028            if !first {
15029                f.write_str(" | ")?;
15030            }
15031            f.write_str("_2_RAY_TRACING_SKIP_AABBS")?;
15032            remaining &= !Self::_2_RAY_TRACING_SKIP_AABBS.0;
15033            first = false;
15034        }
15035        if remaining & Self::_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0 != 0 {
15036            if !first {
15037                f.write_str(" | ")?;
15038            }
15039            f.write_str("_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS")?;
15040            remaining &= !Self::_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0;
15041            first = false;
15042        }
15043        if remaining & Self::_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0 != 0 {
15044            if !first {
15045                f.write_str(" | ")?;
15046            }
15047            f.write_str("_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS")?;
15048            remaining &= !Self::_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0;
15049            first = false;
15050        }
15051        if remaining & Self::_2_RAY_TRACING_NO_NULL_MISS_SHADERS.0 != 0 {
15052            if !first {
15053                f.write_str(" | ")?;
15054            }
15055            f.write_str("_2_RAY_TRACING_NO_NULL_MISS_SHADERS")?;
15056            remaining &= !Self::_2_RAY_TRACING_NO_NULL_MISS_SHADERS.0;
15057            first = false;
15058        }
15059        if remaining & Self::_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0 != 0 {
15060            if !first {
15061                f.write_str(" | ")?;
15062            }
15063            f.write_str("_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS")?;
15064            remaining &= !Self::_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0;
15065            first = false;
15066        }
15067        if remaining & Self::_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0 != 0 {
15068            if !first {
15069                f.write_str(" | ")?;
15070            }
15071            f.write_str("_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY")?;
15072            remaining &= !Self::_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0;
15073            first = false;
15074        }
15075        if remaining & Self::_2_INDIRECT_BINDABLE.0 != 0 {
15076            if !first {
15077                f.write_str(" | ")?;
15078            }
15079            f.write_str("_2_INDIRECT_BINDABLE")?;
15080            remaining &= !Self::_2_INDIRECT_BINDABLE.0;
15081            first = false;
15082        }
15083        if remaining & Self::_2_RAY_TRACING_ALLOW_MOTION.0 != 0 {
15084            if !first {
15085                f.write_str(" | ")?;
15086            }
15087            f.write_str("_2_RAY_TRACING_ALLOW_MOTION")?;
15088            remaining &= !Self::_2_RAY_TRACING_ALLOW_MOTION.0;
15089            first = false;
15090        }
15091        if remaining & Self::_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
15092            if !first {
15093                f.write_str(" | ")?;
15094            }
15095            f.write_str("_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT")?;
15096            remaining &= !Self::_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0;
15097            first = false;
15098        }
15099        if remaining & Self::_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0 != 0 {
15100            if !first {
15101                f.write_str(" | ")?;
15102            }
15103            f.write_str("_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT")?;
15104            remaining &= !Self::_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0;
15105            first = false;
15106        }
15107        if remaining & Self::_2_RAY_TRACING_OPACITY_MICROMAP.0 != 0 {
15108            if !first {
15109                f.write_str(" | ")?;
15110            }
15111            f.write_str("_2_RAY_TRACING_OPACITY_MICROMAP")?;
15112            remaining &= !Self::_2_RAY_TRACING_OPACITY_MICROMAP.0;
15113            first = false;
15114        }
15115        if remaining & Self::_2_COLOR_ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
15116            if !first {
15117                f.write_str(" | ")?;
15118            }
15119            f.write_str("_2_COLOR_ATTACHMENT_FEEDBACK_LOOP")?;
15120            remaining &= !Self::_2_COLOR_ATTACHMENT_FEEDBACK_LOOP.0;
15121            first = false;
15122        }
15123        if remaining & Self::_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
15124            if !first {
15125                f.write_str(" | ")?;
15126            }
15127            f.write_str("_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP")?;
15128            remaining &= !Self::_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0;
15129            first = false;
15130        }
15131        if remaining & Self::_2_RAY_TRACING_DISPLACEMENT_MICROMAP.0 != 0 {
15132            if !first {
15133                f.write_str(" | ")?;
15134            }
15135            f.write_str("_2_RAY_TRACING_DISPLACEMENT_MICROMAP")?;
15136            remaining &= !Self::_2_RAY_TRACING_DISPLACEMENT_MICROMAP.0;
15137            first = false;
15138        }
15139        if remaining & Self::_2_DESCRIPTOR_BUFFER.0 != 0 {
15140            if !first {
15141                f.write_str(" | ")?;
15142            }
15143            f.write_str("_2_DESCRIPTOR_BUFFER")?;
15144            remaining &= !Self::_2_DESCRIPTOR_BUFFER.0;
15145            first = false;
15146        }
15147        if remaining & Self::_2_DISALLOW_OPACITY_MICROMAP_BIT.0 != 0 {
15148            if !first {
15149                f.write_str(" | ")?;
15150            }
15151            f.write_str("_2_DISALLOW_OPACITY_MICROMAP_BIT")?;
15152            remaining &= !Self::_2_DISALLOW_OPACITY_MICROMAP_BIT.0;
15153            first = false;
15154        }
15155        if remaining & Self::_2_INSTRUMENT_SHADERS_BIT.0 != 0 {
15156            if !first {
15157                f.write_str(" | ")?;
15158            }
15159            f.write_str("_2_INSTRUMENT_SHADERS_BIT")?;
15160            remaining &= !Self::_2_INSTRUMENT_SHADERS_BIT.0;
15161            first = false;
15162        }
15163        if remaining & Self::_2_CAPTURE_DATA.0 != 0 {
15164            if !first {
15165                f.write_str(" | ")?;
15166            }
15167            f.write_str("_2_CAPTURE_DATA")?;
15168            remaining &= !Self::_2_CAPTURE_DATA.0;
15169            first = false;
15170        }
15171        if remaining & Self::_2_PER_LAYER_FRAGMENT_DENSITY_BIT.0 != 0 {
15172            if !first {
15173                f.write_str(" | ")?;
15174            }
15175            f.write_str("_2_PER_LAYER_FRAGMENT_DENSITY_BIT")?;
15176            remaining &= !Self::_2_PER_LAYER_FRAGMENT_DENSITY_BIT.0;
15177            first = false;
15178        }
15179        if remaining & Self::_2_64_BIT_INDEXING.0 != 0 {
15180            if !first {
15181                f.write_str(" | ")?;
15182            }
15183            f.write_str("_2_64_BIT_INDEXING")?;
15184            remaining &= !Self::_2_64_BIT_INDEXING.0;
15185            first = false;
15186        }
15187        if remaining != 0u64 {
15188            if !first {
15189                f.write_str(" | ")?;
15190            }
15191            write!(f, "{:#x}", remaining)?;
15192        } else if first {
15193            f.write_str("(empty)")?;
15194        }
15195        Ok(())
15196    }
15197}
15198///[`VkPipelineCreationFeedbackFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackFlagBits.html)
15199#[repr(transparent)]
15200#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
15201#[doc(alias = "VkPipelineCreationFeedbackFlagBits")]
15202pub struct PipelineCreationFeedbackFlagBits(u32);
15203impl PipelineCreationFeedbackFlagBits {
15204    #[inline]
15205    pub const fn empty() -> Self {
15206        Self(0u32)
15207    }
15208    #[inline]
15209    pub const fn from_raw(value: u32) -> Self {
15210        Self(value)
15211    }
15212    #[inline]
15213    pub const fn as_raw(self) -> u32 {
15214        self.0
15215    }
15216    #[inline]
15217    pub const fn is_empty(self) -> bool {
15218        self.0 == 0u32
15219    }
15220    #[inline]
15221    pub const fn contains(self, other: Self) -> bool {
15222        (self.0 & other.0) == other.0
15223    }
15224    #[inline]
15225    pub const fn all() -> Self {
15226        Self(7u32)
15227    }
15228    ///Bit 0.
15229    pub const VALID: Self = Self(1u32);
15230    ///Bit 1.
15231    pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(2u32);
15232    ///Bit 2.
15233    pub const BASE_PIPELINE_ACCELERATION: Self = Self(4u32);
15234}
15235impl core::ops::BitOr for PipelineCreationFeedbackFlagBits {
15236    type Output = Self;
15237    #[inline]
15238    fn bitor(self, rhs: Self) -> Self {
15239        Self(self.0 | rhs.0)
15240    }
15241}
15242impl core::ops::BitOrAssign for PipelineCreationFeedbackFlagBits {
15243    #[inline]
15244    fn bitor_assign(&mut self, rhs: Self) {
15245        self.0 |= rhs.0;
15246    }
15247}
15248impl core::ops::BitAnd for PipelineCreationFeedbackFlagBits {
15249    type Output = Self;
15250    #[inline]
15251    fn bitand(self, rhs: Self) -> Self {
15252        Self(self.0 & rhs.0)
15253    }
15254}
15255impl core::ops::BitAndAssign for PipelineCreationFeedbackFlagBits {
15256    #[inline]
15257    fn bitand_assign(&mut self, rhs: Self) {
15258        self.0 &= rhs.0;
15259    }
15260}
15261impl core::ops::BitXor for PipelineCreationFeedbackFlagBits {
15262    type Output = Self;
15263    #[inline]
15264    fn bitxor(self, rhs: Self) -> Self {
15265        Self(self.0 ^ rhs.0)
15266    }
15267}
15268impl core::ops::BitXorAssign for PipelineCreationFeedbackFlagBits {
15269    #[inline]
15270    fn bitxor_assign(&mut self, rhs: Self) {
15271        self.0 ^= rhs.0;
15272    }
15273}
15274impl core::ops::Not for PipelineCreationFeedbackFlagBits {
15275    type Output = Self;
15276    #[inline]
15277    fn not(self) -> Self {
15278        Self(!self.0)
15279    }
15280}
15281impl core::fmt::Debug for PipelineCreationFeedbackFlagBits {
15282    #[allow(unused_mut, unused_variables)]
15283    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15284        let mut first = true;
15285        let mut remaining = self.0;
15286        if remaining & Self::VALID.0 != 0 {
15287            if !first {
15288                f.write_str(" | ")?;
15289            }
15290            f.write_str("VALID")?;
15291            remaining &= !Self::VALID.0;
15292            first = false;
15293        }
15294        if remaining & Self::APPLICATION_PIPELINE_CACHE_HIT.0 != 0 {
15295            if !first {
15296                f.write_str(" | ")?;
15297            }
15298            f.write_str("APPLICATION_PIPELINE_CACHE_HIT")?;
15299            remaining &= !Self::APPLICATION_PIPELINE_CACHE_HIT.0;
15300            first = false;
15301        }
15302        if remaining & Self::BASE_PIPELINE_ACCELERATION.0 != 0 {
15303            if !first {
15304                f.write_str(" | ")?;
15305            }
15306            f.write_str("BASE_PIPELINE_ACCELERATION")?;
15307            remaining &= !Self::BASE_PIPELINE_ACCELERATION.0;
15308            first = false;
15309        }
15310        if remaining != 0u32 {
15311            if !first {
15312                f.write_str(" | ")?;
15313            }
15314            write!(f, "{:#x}", remaining)?;
15315        } else if first {
15316            f.write_str("(empty)")?;
15317        }
15318        Ok(())
15319    }
15320}
15321///[`VkPipelineDepthStencilStateCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateFlagBits.html)
15322#[repr(transparent)]
15323#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
15324#[doc(alias = "VkPipelineDepthStencilStateCreateFlagBits")]
15325pub struct PipelineDepthStencilStateCreateFlagBits(u32);
15326impl PipelineDepthStencilStateCreateFlagBits {
15327    #[inline]
15328    pub const fn empty() -> Self {
15329        Self(0u32)
15330    }
15331    #[inline]
15332    pub const fn from_raw(value: u32) -> Self {
15333        Self(value)
15334    }
15335    #[inline]
15336    pub const fn as_raw(self) -> u32 {
15337        self.0
15338    }
15339    #[inline]
15340    pub const fn is_empty(self) -> bool {
15341        self.0 == 0u32
15342    }
15343    #[inline]
15344    pub const fn contains(self, other: Self) -> bool {
15345        (self.0 & other.0) == other.0
15346    }
15347    #[inline]
15348    pub const fn all() -> Self {
15349        Self(3u32)
15350    }
15351    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS;
15352    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS;
15353    ///Bit 0.
15354    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS: Self = Self(1u32);
15355    ///Bit 1.
15356    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS: Self = Self(2u32);
15357}
15358impl core::ops::BitOr for PipelineDepthStencilStateCreateFlagBits {
15359    type Output = Self;
15360    #[inline]
15361    fn bitor(self, rhs: Self) -> Self {
15362        Self(self.0 | rhs.0)
15363    }
15364}
15365impl core::ops::BitOrAssign for PipelineDepthStencilStateCreateFlagBits {
15366    #[inline]
15367    fn bitor_assign(&mut self, rhs: Self) {
15368        self.0 |= rhs.0;
15369    }
15370}
15371impl core::ops::BitAnd for PipelineDepthStencilStateCreateFlagBits {
15372    type Output = Self;
15373    #[inline]
15374    fn bitand(self, rhs: Self) -> Self {
15375        Self(self.0 & rhs.0)
15376    }
15377}
15378impl core::ops::BitAndAssign for PipelineDepthStencilStateCreateFlagBits {
15379    #[inline]
15380    fn bitand_assign(&mut self, rhs: Self) {
15381        self.0 &= rhs.0;
15382    }
15383}
15384impl core::ops::BitXor for PipelineDepthStencilStateCreateFlagBits {
15385    type Output = Self;
15386    #[inline]
15387    fn bitxor(self, rhs: Self) -> Self {
15388        Self(self.0 ^ rhs.0)
15389    }
15390}
15391impl core::ops::BitXorAssign for PipelineDepthStencilStateCreateFlagBits {
15392    #[inline]
15393    fn bitxor_assign(&mut self, rhs: Self) {
15394        self.0 ^= rhs.0;
15395    }
15396}
15397impl core::ops::Not for PipelineDepthStencilStateCreateFlagBits {
15398    type Output = Self;
15399    #[inline]
15400    fn not(self) -> Self {
15401        Self(!self.0)
15402    }
15403}
15404impl core::fmt::Debug for PipelineDepthStencilStateCreateFlagBits {
15405    #[allow(unused_mut, unused_variables)]
15406    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15407        let mut first = true;
15408        let mut remaining = self.0;
15409        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS.0 != 0 {
15410            if !first {
15411                f.write_str(" | ")?;
15412            }
15413            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS")?;
15414            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS.0;
15415            first = false;
15416        }
15417        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS.0 != 0 {
15418            if !first {
15419                f.write_str(" | ")?;
15420            }
15421            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS")?;
15422            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS.0;
15423            first = false;
15424        }
15425        if remaining != 0u32 {
15426            if !first {
15427                f.write_str(" | ")?;
15428            }
15429            write!(f, "{:#x}", remaining)?;
15430        } else if first {
15431            f.write_str("(empty)")?;
15432        }
15433        Ok(())
15434    }
15435}
15436///[`VkPipelineLayoutCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlagBits.html)
15437#[repr(transparent)]
15438#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
15439#[doc(alias = "VkPipelineLayoutCreateFlagBits")]
15440pub struct PipelineLayoutCreateFlagBits(u32);
15441impl PipelineLayoutCreateFlagBits {
15442    #[inline]
15443    pub const fn empty() -> Self {
15444        Self(0u32)
15445    }
15446    #[inline]
15447    pub const fn from_raw(value: u32) -> Self {
15448        Self(value)
15449    }
15450    #[inline]
15451    pub const fn as_raw(self) -> u32 {
15452        self.0
15453    }
15454    #[inline]
15455    pub const fn is_empty(self) -> bool {
15456        self.0 == 0u32
15457    }
15458    #[inline]
15459    pub const fn contains(self, other: Self) -> bool {
15460        (self.0 & other.0) == other.0
15461    }
15462    #[inline]
15463    pub const fn all() -> Self {
15464        Self(2u32)
15465    }
15466    ///Bit 1.
15467    pub const INDEPENDENT_SETS: Self = Self(2u32);
15468}
15469impl core::ops::BitOr for PipelineLayoutCreateFlagBits {
15470    type Output = Self;
15471    #[inline]
15472    fn bitor(self, rhs: Self) -> Self {
15473        Self(self.0 | rhs.0)
15474    }
15475}
15476impl core::ops::BitOrAssign for PipelineLayoutCreateFlagBits {
15477    #[inline]
15478    fn bitor_assign(&mut self, rhs: Self) {
15479        self.0 |= rhs.0;
15480    }
15481}
15482impl core::ops::BitAnd for PipelineLayoutCreateFlagBits {
15483    type Output = Self;
15484    #[inline]
15485    fn bitand(self, rhs: Self) -> Self {
15486        Self(self.0 & rhs.0)
15487    }
15488}
15489impl core::ops::BitAndAssign for PipelineLayoutCreateFlagBits {
15490    #[inline]
15491    fn bitand_assign(&mut self, rhs: Self) {
15492        self.0 &= rhs.0;
15493    }
15494}
15495impl core::ops::BitXor for PipelineLayoutCreateFlagBits {
15496    type Output = Self;
15497    #[inline]
15498    fn bitxor(self, rhs: Self) -> Self {
15499        Self(self.0 ^ rhs.0)
15500    }
15501}
15502impl core::ops::BitXorAssign for PipelineLayoutCreateFlagBits {
15503    #[inline]
15504    fn bitxor_assign(&mut self, rhs: Self) {
15505        self.0 ^= rhs.0;
15506    }
15507}
15508impl core::ops::Not for PipelineLayoutCreateFlagBits {
15509    type Output = Self;
15510    #[inline]
15511    fn not(self) -> Self {
15512        Self(!self.0)
15513    }
15514}
15515impl core::fmt::Debug for PipelineLayoutCreateFlagBits {
15516    #[allow(unused_mut, unused_variables)]
15517    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15518        let mut first = true;
15519        let mut remaining = self.0;
15520        if remaining & Self::INDEPENDENT_SETS.0 != 0 {
15521            if !first {
15522                f.write_str(" | ")?;
15523            }
15524            f.write_str("INDEPENDENT_SETS")?;
15525            remaining &= !Self::INDEPENDENT_SETS.0;
15526            first = false;
15527        }
15528        if remaining != 0u32 {
15529            if !first {
15530                f.write_str(" | ")?;
15531            }
15532            write!(f, "{:#x}", remaining)?;
15533        } else if first {
15534            f.write_str("(empty)")?;
15535        }
15536        Ok(())
15537    }
15538}
15539///[`VkPipelineShaderStageCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateFlagBits.html)
15540#[repr(transparent)]
15541#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
15542#[doc(alias = "VkPipelineShaderStageCreateFlagBits")]
15543pub struct PipelineShaderStageCreateFlagBits(u32);
15544impl PipelineShaderStageCreateFlagBits {
15545    #[inline]
15546    pub const fn empty() -> Self {
15547        Self(0u32)
15548    }
15549    #[inline]
15550    pub const fn from_raw(value: u32) -> Self {
15551        Self(value)
15552    }
15553    #[inline]
15554    pub const fn as_raw(self) -> u32 {
15555        self.0
15556    }
15557    #[inline]
15558    pub const fn is_empty(self) -> bool {
15559        self.0 == 0u32
15560    }
15561    #[inline]
15562    pub const fn contains(self, other: Self) -> bool {
15563        (self.0 & other.0) == other.0
15564    }
15565    #[inline]
15566    pub const fn all() -> Self {
15567        Self(3u32)
15568    }
15569    ///Bit 0.
15570    pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(1u32);
15571    ///Bit 1.
15572    pub const REQUIRE_FULL_SUBGROUPS: Self = Self(2u32);
15573}
15574impl core::ops::BitOr for PipelineShaderStageCreateFlagBits {
15575    type Output = Self;
15576    #[inline]
15577    fn bitor(self, rhs: Self) -> Self {
15578        Self(self.0 | rhs.0)
15579    }
15580}
15581impl core::ops::BitOrAssign for PipelineShaderStageCreateFlagBits {
15582    #[inline]
15583    fn bitor_assign(&mut self, rhs: Self) {
15584        self.0 |= rhs.0;
15585    }
15586}
15587impl core::ops::BitAnd for PipelineShaderStageCreateFlagBits {
15588    type Output = Self;
15589    #[inline]
15590    fn bitand(self, rhs: Self) -> Self {
15591        Self(self.0 & rhs.0)
15592    }
15593}
15594impl core::ops::BitAndAssign for PipelineShaderStageCreateFlagBits {
15595    #[inline]
15596    fn bitand_assign(&mut self, rhs: Self) {
15597        self.0 &= rhs.0;
15598    }
15599}
15600impl core::ops::BitXor for PipelineShaderStageCreateFlagBits {
15601    type Output = Self;
15602    #[inline]
15603    fn bitxor(self, rhs: Self) -> Self {
15604        Self(self.0 ^ rhs.0)
15605    }
15606}
15607impl core::ops::BitXorAssign for PipelineShaderStageCreateFlagBits {
15608    #[inline]
15609    fn bitxor_assign(&mut self, rhs: Self) {
15610        self.0 ^= rhs.0;
15611    }
15612}
15613impl core::ops::Not for PipelineShaderStageCreateFlagBits {
15614    type Output = Self;
15615    #[inline]
15616    fn not(self) -> Self {
15617        Self(!self.0)
15618    }
15619}
15620impl core::fmt::Debug for PipelineShaderStageCreateFlagBits {
15621    #[allow(unused_mut, unused_variables)]
15622    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15623        let mut first = true;
15624        let mut remaining = self.0;
15625        if remaining & Self::ALLOW_VARYING_SUBGROUP_SIZE.0 != 0 {
15626            if !first {
15627                f.write_str(" | ")?;
15628            }
15629            f.write_str("ALLOW_VARYING_SUBGROUP_SIZE")?;
15630            remaining &= !Self::ALLOW_VARYING_SUBGROUP_SIZE.0;
15631            first = false;
15632        }
15633        if remaining & Self::REQUIRE_FULL_SUBGROUPS.0 != 0 {
15634            if !first {
15635                f.write_str(" | ")?;
15636            }
15637            f.write_str("REQUIRE_FULL_SUBGROUPS")?;
15638            remaining &= !Self::REQUIRE_FULL_SUBGROUPS.0;
15639            first = false;
15640        }
15641        if remaining != 0u32 {
15642            if !first {
15643                f.write_str(" | ")?;
15644            }
15645            write!(f, "{:#x}", remaining)?;
15646        } else if first {
15647            f.write_str("(empty)")?;
15648        }
15649        Ok(())
15650    }
15651}
15652///[`VkPipelineStageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits.html)
15653#[repr(transparent)]
15654#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
15655#[doc(alias = "VkPipelineStageFlagBits")]
15656pub struct PipelineStageFlagBits(u32);
15657impl PipelineStageFlagBits {
15658    #[inline]
15659    pub const fn empty() -> Self {
15660        Self(0u32)
15661    }
15662    #[inline]
15663    pub const fn from_raw(value: u32) -> Self {
15664        Self(value)
15665    }
15666    #[inline]
15667    pub const fn as_raw(self) -> u32 {
15668        self.0
15669    }
15670    #[inline]
15671    pub const fn is_empty(self) -> bool {
15672        self.0 == 0u32
15673    }
15674    #[inline]
15675    pub const fn contains(self, other: Self) -> bool {
15676        (self.0 & other.0) == other.0
15677    }
15678    #[inline]
15679    pub const fn all() -> Self {
15680        Self(65404927u32)
15681    }
15682    ///Bit 0.
15683    pub const TOP_OF_PIPE: Self = Self(1u32);
15684    ///Bit 1.
15685    pub const DRAW_INDIRECT: Self = Self(2u32);
15686    ///Bit 2.
15687    pub const VERTEX_INPUT: Self = Self(4u32);
15688    ///Bit 3.
15689    pub const VERTEX_SHADER: Self = Self(8u32);
15690    ///Bit 4.
15691    pub const TESSELLATION_CONTROL_SHADER: Self = Self(16u32);
15692    ///Bit 5.
15693    pub const TESSELLATION_EVALUATION_SHADER: Self = Self(32u32);
15694    ///Bit 6.
15695    pub const GEOMETRY_SHADER: Self = Self(64u32);
15696    ///Bit 7.
15697    pub const FRAGMENT_SHADER: Self = Self(128u32);
15698    ///Bit 8.
15699    pub const EARLY_FRAGMENT_TESTS: Self = Self(256u32);
15700    ///Bit 9.
15701    pub const LATE_FRAGMENT_TESTS: Self = Self(512u32);
15702    ///Bit 10.
15703    pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(1024u32);
15704    ///Bit 11.
15705    pub const COMPUTE_SHADER: Self = Self(2048u32);
15706    ///Bit 12.
15707    pub const TRANSFER: Self = Self(4096u32);
15708    ///Bit 13.
15709    pub const BOTTOM_OF_PIPE: Self = Self(8192u32);
15710    ///Bit 14.
15711    pub const HOST: Self = Self(16384u32);
15712    ///Bit 15.
15713    pub const ALL_GRAPHICS: Self = Self(32768u32);
15714    ///Bit 16.
15715    pub const ALL_COMMANDS: Self = Self(65536u32);
15716    pub const NONE: Self = Self(0u32);
15717    ///Bit 24.
15718    pub const TRANSFORM_FEEDBACK: Self = Self(16777216u32);
15719    ///Bit 18.
15720    pub const CONDITIONAL_RENDERING: Self = Self(262144u32);
15721    ///Bit 25.
15722    pub const ACCELERATION_STRUCTURE_BUILD: Self = Self(33554432u32);
15723    ///Bit 21.
15724    pub const RAY_TRACING_SHADER: Self = Self(2097152u32);
15725    pub const SHADING_RATE_IMAGE: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT;
15726    ///Bit 23.
15727    pub const FRAGMENT_DENSITY_PROCESS: Self = Self(8388608u32);
15728    ///Bit 22.
15729    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(4194304u32);
15730}
15731impl core::ops::BitOr for PipelineStageFlagBits {
15732    type Output = Self;
15733    #[inline]
15734    fn bitor(self, rhs: Self) -> Self {
15735        Self(self.0 | rhs.0)
15736    }
15737}
15738impl core::ops::BitOrAssign for PipelineStageFlagBits {
15739    #[inline]
15740    fn bitor_assign(&mut self, rhs: Self) {
15741        self.0 |= rhs.0;
15742    }
15743}
15744impl core::ops::BitAnd for PipelineStageFlagBits {
15745    type Output = Self;
15746    #[inline]
15747    fn bitand(self, rhs: Self) -> Self {
15748        Self(self.0 & rhs.0)
15749    }
15750}
15751impl core::ops::BitAndAssign for PipelineStageFlagBits {
15752    #[inline]
15753    fn bitand_assign(&mut self, rhs: Self) {
15754        self.0 &= rhs.0;
15755    }
15756}
15757impl core::ops::BitXor for PipelineStageFlagBits {
15758    type Output = Self;
15759    #[inline]
15760    fn bitxor(self, rhs: Self) -> Self {
15761        Self(self.0 ^ rhs.0)
15762    }
15763}
15764impl core::ops::BitXorAssign for PipelineStageFlagBits {
15765    #[inline]
15766    fn bitxor_assign(&mut self, rhs: Self) {
15767        self.0 ^= rhs.0;
15768    }
15769}
15770impl core::ops::Not for PipelineStageFlagBits {
15771    type Output = Self;
15772    #[inline]
15773    fn not(self) -> Self {
15774        Self(!self.0)
15775    }
15776}
15777impl core::fmt::Debug for PipelineStageFlagBits {
15778    #[allow(unused_mut, unused_variables)]
15779    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15780        let mut first = true;
15781        let mut remaining = self.0;
15782        if remaining & Self::TOP_OF_PIPE.0 != 0 {
15783            if !first {
15784                f.write_str(" | ")?;
15785            }
15786            f.write_str("TOP_OF_PIPE")?;
15787            remaining &= !Self::TOP_OF_PIPE.0;
15788            first = false;
15789        }
15790        if remaining & Self::DRAW_INDIRECT.0 != 0 {
15791            if !first {
15792                f.write_str(" | ")?;
15793            }
15794            f.write_str("DRAW_INDIRECT")?;
15795            remaining &= !Self::DRAW_INDIRECT.0;
15796            first = false;
15797        }
15798        if remaining & Self::VERTEX_INPUT.0 != 0 {
15799            if !first {
15800                f.write_str(" | ")?;
15801            }
15802            f.write_str("VERTEX_INPUT")?;
15803            remaining &= !Self::VERTEX_INPUT.0;
15804            first = false;
15805        }
15806        if remaining & Self::VERTEX_SHADER.0 != 0 {
15807            if !first {
15808                f.write_str(" | ")?;
15809            }
15810            f.write_str("VERTEX_SHADER")?;
15811            remaining &= !Self::VERTEX_SHADER.0;
15812            first = false;
15813        }
15814        if remaining & Self::TESSELLATION_CONTROL_SHADER.0 != 0 {
15815            if !first {
15816                f.write_str(" | ")?;
15817            }
15818            f.write_str("TESSELLATION_CONTROL_SHADER")?;
15819            remaining &= !Self::TESSELLATION_CONTROL_SHADER.0;
15820            first = false;
15821        }
15822        if remaining & Self::TESSELLATION_EVALUATION_SHADER.0 != 0 {
15823            if !first {
15824                f.write_str(" | ")?;
15825            }
15826            f.write_str("TESSELLATION_EVALUATION_SHADER")?;
15827            remaining &= !Self::TESSELLATION_EVALUATION_SHADER.0;
15828            first = false;
15829        }
15830        if remaining & Self::GEOMETRY_SHADER.0 != 0 {
15831            if !first {
15832                f.write_str(" | ")?;
15833            }
15834            f.write_str("GEOMETRY_SHADER")?;
15835            remaining &= !Self::GEOMETRY_SHADER.0;
15836            first = false;
15837        }
15838        if remaining & Self::FRAGMENT_SHADER.0 != 0 {
15839            if !first {
15840                f.write_str(" | ")?;
15841            }
15842            f.write_str("FRAGMENT_SHADER")?;
15843            remaining &= !Self::FRAGMENT_SHADER.0;
15844            first = false;
15845        }
15846        if remaining & Self::EARLY_FRAGMENT_TESTS.0 != 0 {
15847            if !first {
15848                f.write_str(" | ")?;
15849            }
15850            f.write_str("EARLY_FRAGMENT_TESTS")?;
15851            remaining &= !Self::EARLY_FRAGMENT_TESTS.0;
15852            first = false;
15853        }
15854        if remaining & Self::LATE_FRAGMENT_TESTS.0 != 0 {
15855            if !first {
15856                f.write_str(" | ")?;
15857            }
15858            f.write_str("LATE_FRAGMENT_TESTS")?;
15859            remaining &= !Self::LATE_FRAGMENT_TESTS.0;
15860            first = false;
15861        }
15862        if remaining & Self::COLOR_ATTACHMENT_OUTPUT.0 != 0 {
15863            if !first {
15864                f.write_str(" | ")?;
15865            }
15866            f.write_str("COLOR_ATTACHMENT_OUTPUT")?;
15867            remaining &= !Self::COLOR_ATTACHMENT_OUTPUT.0;
15868            first = false;
15869        }
15870        if remaining & Self::COMPUTE_SHADER.0 != 0 {
15871            if !first {
15872                f.write_str(" | ")?;
15873            }
15874            f.write_str("COMPUTE_SHADER")?;
15875            remaining &= !Self::COMPUTE_SHADER.0;
15876            first = false;
15877        }
15878        if remaining & Self::TRANSFER.0 != 0 {
15879            if !first {
15880                f.write_str(" | ")?;
15881            }
15882            f.write_str("TRANSFER")?;
15883            remaining &= !Self::TRANSFER.0;
15884            first = false;
15885        }
15886        if remaining & Self::BOTTOM_OF_PIPE.0 != 0 {
15887            if !first {
15888                f.write_str(" | ")?;
15889            }
15890            f.write_str("BOTTOM_OF_PIPE")?;
15891            remaining &= !Self::BOTTOM_OF_PIPE.0;
15892            first = false;
15893        }
15894        if remaining & Self::HOST.0 != 0 {
15895            if !first {
15896                f.write_str(" | ")?;
15897            }
15898            f.write_str("HOST")?;
15899            remaining &= !Self::HOST.0;
15900            first = false;
15901        }
15902        if remaining & Self::ALL_GRAPHICS.0 != 0 {
15903            if !first {
15904                f.write_str(" | ")?;
15905            }
15906            f.write_str("ALL_GRAPHICS")?;
15907            remaining &= !Self::ALL_GRAPHICS.0;
15908            first = false;
15909        }
15910        if remaining & Self::ALL_COMMANDS.0 != 0 {
15911            if !first {
15912                f.write_str(" | ")?;
15913            }
15914            f.write_str("ALL_COMMANDS")?;
15915            remaining &= !Self::ALL_COMMANDS.0;
15916            first = false;
15917        }
15918        if remaining & Self::TRANSFORM_FEEDBACK.0 != 0 {
15919            if !first {
15920                f.write_str(" | ")?;
15921            }
15922            f.write_str("TRANSFORM_FEEDBACK")?;
15923            remaining &= !Self::TRANSFORM_FEEDBACK.0;
15924            first = false;
15925        }
15926        if remaining & Self::CONDITIONAL_RENDERING.0 != 0 {
15927            if !first {
15928                f.write_str(" | ")?;
15929            }
15930            f.write_str("CONDITIONAL_RENDERING")?;
15931            remaining &= !Self::CONDITIONAL_RENDERING.0;
15932            first = false;
15933        }
15934        if remaining & Self::ACCELERATION_STRUCTURE_BUILD.0 != 0 {
15935            if !first {
15936                f.write_str(" | ")?;
15937            }
15938            f.write_str("ACCELERATION_STRUCTURE_BUILD")?;
15939            remaining &= !Self::ACCELERATION_STRUCTURE_BUILD.0;
15940            first = false;
15941        }
15942        if remaining & Self::RAY_TRACING_SHADER.0 != 0 {
15943            if !first {
15944                f.write_str(" | ")?;
15945            }
15946            f.write_str("RAY_TRACING_SHADER")?;
15947            remaining &= !Self::RAY_TRACING_SHADER.0;
15948            first = false;
15949        }
15950        if remaining & Self::FRAGMENT_DENSITY_PROCESS.0 != 0 {
15951            if !first {
15952                f.write_str(" | ")?;
15953            }
15954            f.write_str("FRAGMENT_DENSITY_PROCESS")?;
15955            remaining &= !Self::FRAGMENT_DENSITY_PROCESS.0;
15956            first = false;
15957        }
15958        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
15959            if !first {
15960                f.write_str(" | ")?;
15961            }
15962            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT")?;
15963            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0;
15964            first = false;
15965        }
15966        if remaining != 0u32 {
15967            if !first {
15968                f.write_str(" | ")?;
15969            }
15970            write!(f, "{:#x}", remaining)?;
15971        } else if first {
15972            f.write_str("(empty)")?;
15973        }
15974        Ok(())
15975    }
15976}
15977///[`VkPipelineStageFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits2.html)
15978#[repr(transparent)]
15979#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
15980#[doc(alias = "VkPipelineStageFlagBits2")]
15981pub struct PipelineStageFlagBits2(u64);
15982impl PipelineStageFlagBits2 {
15983    #[inline]
15984    pub const fn empty() -> Self {
15985        Self(0u64)
15986    }
15987    #[inline]
15988    pub const fn from_raw(value: u64) -> Self {
15989        Self(value)
15990    }
15991    #[inline]
15992    pub const fn as_raw(self) -> u64 {
15993        self.0
15994    }
15995    #[inline]
15996    pub const fn is_empty(self) -> bool {
15997        self.0 == 0u64
15998    }
15999    #[inline]
16000    pub const fn contains(self, other: Self) -> bool {
16001        (self.0 & other.0) == other.0
16002    }
16003    #[inline]
16004    pub const fn all() -> Self {
16005        Self(131939246145535u64)
16006    }
16007    pub const _2_NONE: Self = Self(0u64);
16008    ///Bit 0.
16009    pub const _2_TOP_OF_PIPE: Self = Self(1u64);
16010    ///Bit 1.
16011    pub const _2_DRAW_INDIRECT: Self = Self(2u64);
16012    ///Bit 2.
16013    pub const _2_VERTEX_INPUT: Self = Self(4u64);
16014    ///Bit 3.
16015    pub const _2_VERTEX_SHADER: Self = Self(8u64);
16016    ///Bit 4.
16017    pub const _2_TESSELLATION_CONTROL_SHADER: Self = Self(16u64);
16018    ///Bit 5.
16019    pub const _2_TESSELLATION_EVALUATION_SHADER: Self = Self(32u64);
16020    ///Bit 6.
16021    pub const _2_GEOMETRY_SHADER: Self = Self(64u64);
16022    ///Bit 7.
16023    pub const _2_FRAGMENT_SHADER: Self = Self(128u64);
16024    ///Bit 8.
16025    pub const _2_EARLY_FRAGMENT_TESTS: Self = Self(256u64);
16026    ///Bit 9.
16027    pub const _2_LATE_FRAGMENT_TESTS: Self = Self(512u64);
16028    ///Bit 10.
16029    pub const _2_COLOR_ATTACHMENT_OUTPUT: Self = Self(1024u64);
16030    ///Bit 11.
16031    pub const _2_COMPUTE_SHADER: Self = Self(2048u64);
16032    ///Bit 12.
16033    pub const _2_ALL_TRANSFER: Self = Self(4096u64);
16034    pub const _2_TRANSFER: Self = Self::_2_ALL_TRANSFER;
16035    ///Bit 13.
16036    pub const _2_BOTTOM_OF_PIPE: Self = Self(8192u64);
16037    ///Bit 14.
16038    pub const _2_HOST: Self = Self(16384u64);
16039    ///Bit 15.
16040    pub const _2_ALL_GRAPHICS: Self = Self(32768u64);
16041    ///Bit 16.
16042    pub const _2_ALL_COMMANDS: Self = Self(65536u64);
16043    ///Bit 32.
16044    pub const _2_COPY: Self = Self(4294967296u64);
16045    ///Bit 33.
16046    pub const _2_RESOLVE: Self = Self(8589934592u64);
16047    ///Bit 34.
16048    pub const _2_BLIT: Self = Self(17179869184u64);
16049    ///Bit 35.
16050    pub const _2_CLEAR: Self = Self(34359738368u64);
16051    ///Bit 36.
16052    pub const _2_INDEX_INPUT: Self = Self(68719476736u64);
16053    ///Bit 37.
16054    pub const _2_VERTEX_ATTRIBUTE_INPUT: Self = Self(137438953472u64);
16055    ///Bit 38.
16056    pub const _2_PRE_RASTERIZATION_SHADERS: Self = Self(274877906944u64);
16057    ///Bit 26.
16058    pub const _2_VIDEO_DECODE: Self = Self(67108864u64);
16059    ///Bit 27.
16060    pub const _2_VIDEO_ENCODE: Self = Self(134217728u64);
16061    ///Bit 24.
16062    pub const _2_TRANSFORM_FEEDBACK: Self = Self(16777216u64);
16063    ///Bit 18.
16064    pub const _2_CONDITIONAL_RENDERING: Self = Self(262144u64);
16065    ///Bit 22.
16066    pub const _2_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(4194304u64);
16067    pub const _2_SHADING_RATE_IMAGE: Self = Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT;
16068    ///Bit 25.
16069    pub const _2_ACCELERATION_STRUCTURE_BUILD: Self = Self(33554432u64);
16070    ///Bit 21.
16071    pub const _2_RAY_TRACING_SHADER: Self = Self(2097152u64);
16072    ///Bit 23.
16073    pub const _2_FRAGMENT_DENSITY_PROCESS: Self = Self(8388608u64);
16074    ///Bit 39.
16075    pub const _2_SUBPASS_SHADER_BIT: Self = Self(549755813888u64);
16076    pub const _2_SUBPASS_SHADING_BIT: Self = Self::_2_SUBPASS_SHADER_BIT;
16077    ///Bit 40.
16078    pub const _2_INVOCATION_MASK_BIT: Self = Self(1099511627776u64);
16079    ///Bit 28.
16080    pub const _2_ACCELERATION_STRUCTURE_COPY: Self = Self(268435456u64);
16081    ///Bit 30.
16082    pub const _2_MICROMAP_BUILD: Self = Self(1073741824u64);
16083    ///Bit 41.
16084    pub const _2_CLUSTER_CULLING_SHADER_BIT: Self = Self(2199023255552u64);
16085    ///Bit 29.
16086    pub const _2_OPTICAL_FLOW: Self = Self(536870912u64);
16087    ///Bit 44.
16088    pub const _2_CONVERT_COOPERATIVE_VECTOR_MATRIX: Self = Self(17592186044416u64);
16089    ///Bit 42.
16090    pub const _2_DATA_GRAPH_BIT: Self = Self(4398046511104u64);
16091    ///Bit 46.
16092    pub const _2_COPY_INDIRECT: Self = Self(70368744177664u64);
16093    ///Bit 45.
16094    pub const _2_MEMORY_DECOMPRESSION: Self = Self(35184372088832u64);
16095}
16096impl core::ops::BitOr for PipelineStageFlagBits2 {
16097    type Output = Self;
16098    #[inline]
16099    fn bitor(self, rhs: Self) -> Self {
16100        Self(self.0 | rhs.0)
16101    }
16102}
16103impl core::ops::BitOrAssign for PipelineStageFlagBits2 {
16104    #[inline]
16105    fn bitor_assign(&mut self, rhs: Self) {
16106        self.0 |= rhs.0;
16107    }
16108}
16109impl core::ops::BitAnd for PipelineStageFlagBits2 {
16110    type Output = Self;
16111    #[inline]
16112    fn bitand(self, rhs: Self) -> Self {
16113        Self(self.0 & rhs.0)
16114    }
16115}
16116impl core::ops::BitAndAssign for PipelineStageFlagBits2 {
16117    #[inline]
16118    fn bitand_assign(&mut self, rhs: Self) {
16119        self.0 &= rhs.0;
16120    }
16121}
16122impl core::ops::BitXor for PipelineStageFlagBits2 {
16123    type Output = Self;
16124    #[inline]
16125    fn bitxor(self, rhs: Self) -> Self {
16126        Self(self.0 ^ rhs.0)
16127    }
16128}
16129impl core::ops::BitXorAssign for PipelineStageFlagBits2 {
16130    #[inline]
16131    fn bitxor_assign(&mut self, rhs: Self) {
16132        self.0 ^= rhs.0;
16133    }
16134}
16135impl core::ops::Not for PipelineStageFlagBits2 {
16136    type Output = Self;
16137    #[inline]
16138    fn not(self) -> Self {
16139        Self(!self.0)
16140    }
16141}
16142impl core::fmt::Debug for PipelineStageFlagBits2 {
16143    #[allow(unused_mut, unused_variables)]
16144    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16145        let mut first = true;
16146        let mut remaining = self.0;
16147        if remaining & Self::_2_TOP_OF_PIPE.0 != 0 {
16148            if !first {
16149                f.write_str(" | ")?;
16150            }
16151            f.write_str("_2_TOP_OF_PIPE")?;
16152            remaining &= !Self::_2_TOP_OF_PIPE.0;
16153            first = false;
16154        }
16155        if remaining & Self::_2_DRAW_INDIRECT.0 != 0 {
16156            if !first {
16157                f.write_str(" | ")?;
16158            }
16159            f.write_str("_2_DRAW_INDIRECT")?;
16160            remaining &= !Self::_2_DRAW_INDIRECT.0;
16161            first = false;
16162        }
16163        if remaining & Self::_2_VERTEX_INPUT.0 != 0 {
16164            if !first {
16165                f.write_str(" | ")?;
16166            }
16167            f.write_str("_2_VERTEX_INPUT")?;
16168            remaining &= !Self::_2_VERTEX_INPUT.0;
16169            first = false;
16170        }
16171        if remaining & Self::_2_VERTEX_SHADER.0 != 0 {
16172            if !first {
16173                f.write_str(" | ")?;
16174            }
16175            f.write_str("_2_VERTEX_SHADER")?;
16176            remaining &= !Self::_2_VERTEX_SHADER.0;
16177            first = false;
16178        }
16179        if remaining & Self::_2_TESSELLATION_CONTROL_SHADER.0 != 0 {
16180            if !first {
16181                f.write_str(" | ")?;
16182            }
16183            f.write_str("_2_TESSELLATION_CONTROL_SHADER")?;
16184            remaining &= !Self::_2_TESSELLATION_CONTROL_SHADER.0;
16185            first = false;
16186        }
16187        if remaining & Self::_2_TESSELLATION_EVALUATION_SHADER.0 != 0 {
16188            if !first {
16189                f.write_str(" | ")?;
16190            }
16191            f.write_str("_2_TESSELLATION_EVALUATION_SHADER")?;
16192            remaining &= !Self::_2_TESSELLATION_EVALUATION_SHADER.0;
16193            first = false;
16194        }
16195        if remaining & Self::_2_GEOMETRY_SHADER.0 != 0 {
16196            if !first {
16197                f.write_str(" | ")?;
16198            }
16199            f.write_str("_2_GEOMETRY_SHADER")?;
16200            remaining &= !Self::_2_GEOMETRY_SHADER.0;
16201            first = false;
16202        }
16203        if remaining & Self::_2_FRAGMENT_SHADER.0 != 0 {
16204            if !first {
16205                f.write_str(" | ")?;
16206            }
16207            f.write_str("_2_FRAGMENT_SHADER")?;
16208            remaining &= !Self::_2_FRAGMENT_SHADER.0;
16209            first = false;
16210        }
16211        if remaining & Self::_2_EARLY_FRAGMENT_TESTS.0 != 0 {
16212            if !first {
16213                f.write_str(" | ")?;
16214            }
16215            f.write_str("_2_EARLY_FRAGMENT_TESTS")?;
16216            remaining &= !Self::_2_EARLY_FRAGMENT_TESTS.0;
16217            first = false;
16218        }
16219        if remaining & Self::_2_LATE_FRAGMENT_TESTS.0 != 0 {
16220            if !first {
16221                f.write_str(" | ")?;
16222            }
16223            f.write_str("_2_LATE_FRAGMENT_TESTS")?;
16224            remaining &= !Self::_2_LATE_FRAGMENT_TESTS.0;
16225            first = false;
16226        }
16227        if remaining & Self::_2_COLOR_ATTACHMENT_OUTPUT.0 != 0 {
16228            if !first {
16229                f.write_str(" | ")?;
16230            }
16231            f.write_str("_2_COLOR_ATTACHMENT_OUTPUT")?;
16232            remaining &= !Self::_2_COLOR_ATTACHMENT_OUTPUT.0;
16233            first = false;
16234        }
16235        if remaining & Self::_2_COMPUTE_SHADER.0 != 0 {
16236            if !first {
16237                f.write_str(" | ")?;
16238            }
16239            f.write_str("_2_COMPUTE_SHADER")?;
16240            remaining &= !Self::_2_COMPUTE_SHADER.0;
16241            first = false;
16242        }
16243        if remaining & Self::_2_ALL_TRANSFER.0 != 0 {
16244            if !first {
16245                f.write_str(" | ")?;
16246            }
16247            f.write_str("_2_ALL_TRANSFER")?;
16248            remaining &= !Self::_2_ALL_TRANSFER.0;
16249            first = false;
16250        }
16251        if remaining & Self::_2_BOTTOM_OF_PIPE.0 != 0 {
16252            if !first {
16253                f.write_str(" | ")?;
16254            }
16255            f.write_str("_2_BOTTOM_OF_PIPE")?;
16256            remaining &= !Self::_2_BOTTOM_OF_PIPE.0;
16257            first = false;
16258        }
16259        if remaining & Self::_2_HOST.0 != 0 {
16260            if !first {
16261                f.write_str(" | ")?;
16262            }
16263            f.write_str("_2_HOST")?;
16264            remaining &= !Self::_2_HOST.0;
16265            first = false;
16266        }
16267        if remaining & Self::_2_ALL_GRAPHICS.0 != 0 {
16268            if !first {
16269                f.write_str(" | ")?;
16270            }
16271            f.write_str("_2_ALL_GRAPHICS")?;
16272            remaining &= !Self::_2_ALL_GRAPHICS.0;
16273            first = false;
16274        }
16275        if remaining & Self::_2_ALL_COMMANDS.0 != 0 {
16276            if !first {
16277                f.write_str(" | ")?;
16278            }
16279            f.write_str("_2_ALL_COMMANDS")?;
16280            remaining &= !Self::_2_ALL_COMMANDS.0;
16281            first = false;
16282        }
16283        if remaining & Self::_2_COPY.0 != 0 {
16284            if !first {
16285                f.write_str(" | ")?;
16286            }
16287            f.write_str("_2_COPY")?;
16288            remaining &= !Self::_2_COPY.0;
16289            first = false;
16290        }
16291        if remaining & Self::_2_RESOLVE.0 != 0 {
16292            if !first {
16293                f.write_str(" | ")?;
16294            }
16295            f.write_str("_2_RESOLVE")?;
16296            remaining &= !Self::_2_RESOLVE.0;
16297            first = false;
16298        }
16299        if remaining & Self::_2_BLIT.0 != 0 {
16300            if !first {
16301                f.write_str(" | ")?;
16302            }
16303            f.write_str("_2_BLIT")?;
16304            remaining &= !Self::_2_BLIT.0;
16305            first = false;
16306        }
16307        if remaining & Self::_2_CLEAR.0 != 0 {
16308            if !first {
16309                f.write_str(" | ")?;
16310            }
16311            f.write_str("_2_CLEAR")?;
16312            remaining &= !Self::_2_CLEAR.0;
16313            first = false;
16314        }
16315        if remaining & Self::_2_INDEX_INPUT.0 != 0 {
16316            if !first {
16317                f.write_str(" | ")?;
16318            }
16319            f.write_str("_2_INDEX_INPUT")?;
16320            remaining &= !Self::_2_INDEX_INPUT.0;
16321            first = false;
16322        }
16323        if remaining & Self::_2_VERTEX_ATTRIBUTE_INPUT.0 != 0 {
16324            if !first {
16325                f.write_str(" | ")?;
16326            }
16327            f.write_str("_2_VERTEX_ATTRIBUTE_INPUT")?;
16328            remaining &= !Self::_2_VERTEX_ATTRIBUTE_INPUT.0;
16329            first = false;
16330        }
16331        if remaining & Self::_2_PRE_RASTERIZATION_SHADERS.0 != 0 {
16332            if !first {
16333                f.write_str(" | ")?;
16334            }
16335            f.write_str("_2_PRE_RASTERIZATION_SHADERS")?;
16336            remaining &= !Self::_2_PRE_RASTERIZATION_SHADERS.0;
16337            first = false;
16338        }
16339        if remaining & Self::_2_VIDEO_DECODE.0 != 0 {
16340            if !first {
16341                f.write_str(" | ")?;
16342            }
16343            f.write_str("_2_VIDEO_DECODE")?;
16344            remaining &= !Self::_2_VIDEO_DECODE.0;
16345            first = false;
16346        }
16347        if remaining & Self::_2_VIDEO_ENCODE.0 != 0 {
16348            if !first {
16349                f.write_str(" | ")?;
16350            }
16351            f.write_str("_2_VIDEO_ENCODE")?;
16352            remaining &= !Self::_2_VIDEO_ENCODE.0;
16353            first = false;
16354        }
16355        if remaining & Self::_2_TRANSFORM_FEEDBACK.0 != 0 {
16356            if !first {
16357                f.write_str(" | ")?;
16358            }
16359            f.write_str("_2_TRANSFORM_FEEDBACK")?;
16360            remaining &= !Self::_2_TRANSFORM_FEEDBACK.0;
16361            first = false;
16362        }
16363        if remaining & Self::_2_CONDITIONAL_RENDERING.0 != 0 {
16364            if !first {
16365                f.write_str(" | ")?;
16366            }
16367            f.write_str("_2_CONDITIONAL_RENDERING")?;
16368            remaining &= !Self::_2_CONDITIONAL_RENDERING.0;
16369            first = false;
16370        }
16371        if remaining & Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
16372            if !first {
16373                f.write_str(" | ")?;
16374            }
16375            f.write_str("_2_FRAGMENT_SHADING_RATE_ATTACHMENT")?;
16376            remaining &= !Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT.0;
16377            first = false;
16378        }
16379        if remaining & Self::_2_ACCELERATION_STRUCTURE_BUILD.0 != 0 {
16380            if !first {
16381                f.write_str(" | ")?;
16382            }
16383            f.write_str("_2_ACCELERATION_STRUCTURE_BUILD")?;
16384            remaining &= !Self::_2_ACCELERATION_STRUCTURE_BUILD.0;
16385            first = false;
16386        }
16387        if remaining & Self::_2_RAY_TRACING_SHADER.0 != 0 {
16388            if !first {
16389                f.write_str(" | ")?;
16390            }
16391            f.write_str("_2_RAY_TRACING_SHADER")?;
16392            remaining &= !Self::_2_RAY_TRACING_SHADER.0;
16393            first = false;
16394        }
16395        if remaining & Self::_2_FRAGMENT_DENSITY_PROCESS.0 != 0 {
16396            if !first {
16397                f.write_str(" | ")?;
16398            }
16399            f.write_str("_2_FRAGMENT_DENSITY_PROCESS")?;
16400            remaining &= !Self::_2_FRAGMENT_DENSITY_PROCESS.0;
16401            first = false;
16402        }
16403        if remaining & Self::_2_SUBPASS_SHADER_BIT.0 != 0 {
16404            if !first {
16405                f.write_str(" | ")?;
16406            }
16407            f.write_str("_2_SUBPASS_SHADER_BIT")?;
16408            remaining &= !Self::_2_SUBPASS_SHADER_BIT.0;
16409            first = false;
16410        }
16411        if remaining & Self::_2_INVOCATION_MASK_BIT.0 != 0 {
16412            if !first {
16413                f.write_str(" | ")?;
16414            }
16415            f.write_str("_2_INVOCATION_MASK_BIT")?;
16416            remaining &= !Self::_2_INVOCATION_MASK_BIT.0;
16417            first = false;
16418        }
16419        if remaining & Self::_2_ACCELERATION_STRUCTURE_COPY.0 != 0 {
16420            if !first {
16421                f.write_str(" | ")?;
16422            }
16423            f.write_str("_2_ACCELERATION_STRUCTURE_COPY")?;
16424            remaining &= !Self::_2_ACCELERATION_STRUCTURE_COPY.0;
16425            first = false;
16426        }
16427        if remaining & Self::_2_MICROMAP_BUILD.0 != 0 {
16428            if !first {
16429                f.write_str(" | ")?;
16430            }
16431            f.write_str("_2_MICROMAP_BUILD")?;
16432            remaining &= !Self::_2_MICROMAP_BUILD.0;
16433            first = false;
16434        }
16435        if remaining & Self::_2_CLUSTER_CULLING_SHADER_BIT.0 != 0 {
16436            if !first {
16437                f.write_str(" | ")?;
16438            }
16439            f.write_str("_2_CLUSTER_CULLING_SHADER_BIT")?;
16440            remaining &= !Self::_2_CLUSTER_CULLING_SHADER_BIT.0;
16441            first = false;
16442        }
16443        if remaining & Self::_2_OPTICAL_FLOW.0 != 0 {
16444            if !first {
16445                f.write_str(" | ")?;
16446            }
16447            f.write_str("_2_OPTICAL_FLOW")?;
16448            remaining &= !Self::_2_OPTICAL_FLOW.0;
16449            first = false;
16450        }
16451        if remaining & Self::_2_CONVERT_COOPERATIVE_VECTOR_MATRIX.0 != 0 {
16452            if !first {
16453                f.write_str(" | ")?;
16454            }
16455            f.write_str("_2_CONVERT_COOPERATIVE_VECTOR_MATRIX")?;
16456            remaining &= !Self::_2_CONVERT_COOPERATIVE_VECTOR_MATRIX.0;
16457            first = false;
16458        }
16459        if remaining & Self::_2_DATA_GRAPH_BIT.0 != 0 {
16460            if !first {
16461                f.write_str(" | ")?;
16462            }
16463            f.write_str("_2_DATA_GRAPH_BIT")?;
16464            remaining &= !Self::_2_DATA_GRAPH_BIT.0;
16465            first = false;
16466        }
16467        if remaining & Self::_2_COPY_INDIRECT.0 != 0 {
16468            if !first {
16469                f.write_str(" | ")?;
16470            }
16471            f.write_str("_2_COPY_INDIRECT")?;
16472            remaining &= !Self::_2_COPY_INDIRECT.0;
16473            first = false;
16474        }
16475        if remaining & Self::_2_MEMORY_DECOMPRESSION.0 != 0 {
16476            if !first {
16477                f.write_str(" | ")?;
16478            }
16479            f.write_str("_2_MEMORY_DECOMPRESSION")?;
16480            remaining &= !Self::_2_MEMORY_DECOMPRESSION.0;
16481            first = false;
16482        }
16483        if remaining != 0u64 {
16484            if !first {
16485                f.write_str(" | ")?;
16486            }
16487            write!(f, "{:#x}", remaining)?;
16488        } else if first {
16489            f.write_str("(empty)")?;
16490        }
16491        Ok(())
16492    }
16493}
16494///[`VkPresentGravityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentGravityFlagBitsKHR.html)
16495#[repr(transparent)]
16496#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
16497#[doc(alias = "VkPresentGravityFlagBitsKHR")]
16498pub struct PresentGravityFlagBitsKHR(u32);
16499impl PresentGravityFlagBitsKHR {
16500    #[inline]
16501    pub const fn empty() -> Self {
16502        Self(0u32)
16503    }
16504    #[inline]
16505    pub const fn from_raw(value: u32) -> Self {
16506        Self(value)
16507    }
16508    #[inline]
16509    pub const fn as_raw(self) -> u32 {
16510        self.0
16511    }
16512    #[inline]
16513    pub const fn is_empty(self) -> bool {
16514        self.0 == 0u32
16515    }
16516    #[inline]
16517    pub const fn contains(self, other: Self) -> bool {
16518        (self.0 & other.0) == other.0
16519    }
16520    #[inline]
16521    pub const fn all() -> Self {
16522        Self(7u32)
16523    }
16524    ///Bit 0.
16525    pub const MIN: Self = Self(1u32);
16526    ///Bit 1.
16527    pub const MAX: Self = Self(2u32);
16528    ///Bit 2.
16529    pub const CENTERED: Self = Self(4u32);
16530}
16531impl core::ops::BitOr for PresentGravityFlagBitsKHR {
16532    type Output = Self;
16533    #[inline]
16534    fn bitor(self, rhs: Self) -> Self {
16535        Self(self.0 | rhs.0)
16536    }
16537}
16538impl core::ops::BitOrAssign for PresentGravityFlagBitsKHR {
16539    #[inline]
16540    fn bitor_assign(&mut self, rhs: Self) {
16541        self.0 |= rhs.0;
16542    }
16543}
16544impl core::ops::BitAnd for PresentGravityFlagBitsKHR {
16545    type Output = Self;
16546    #[inline]
16547    fn bitand(self, rhs: Self) -> Self {
16548        Self(self.0 & rhs.0)
16549    }
16550}
16551impl core::ops::BitAndAssign for PresentGravityFlagBitsKHR {
16552    #[inline]
16553    fn bitand_assign(&mut self, rhs: Self) {
16554        self.0 &= rhs.0;
16555    }
16556}
16557impl core::ops::BitXor for PresentGravityFlagBitsKHR {
16558    type Output = Self;
16559    #[inline]
16560    fn bitxor(self, rhs: Self) -> Self {
16561        Self(self.0 ^ rhs.0)
16562    }
16563}
16564impl core::ops::BitXorAssign for PresentGravityFlagBitsKHR {
16565    #[inline]
16566    fn bitxor_assign(&mut self, rhs: Self) {
16567        self.0 ^= rhs.0;
16568    }
16569}
16570impl core::ops::Not for PresentGravityFlagBitsKHR {
16571    type Output = Self;
16572    #[inline]
16573    fn not(self) -> Self {
16574        Self(!self.0)
16575    }
16576}
16577impl core::fmt::Debug for PresentGravityFlagBitsKHR {
16578    #[allow(unused_mut, unused_variables)]
16579    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16580        let mut first = true;
16581        let mut remaining = self.0;
16582        if remaining & Self::MIN.0 != 0 {
16583            if !first {
16584                f.write_str(" | ")?;
16585            }
16586            f.write_str("MIN")?;
16587            remaining &= !Self::MIN.0;
16588            first = false;
16589        }
16590        if remaining & Self::MAX.0 != 0 {
16591            if !first {
16592                f.write_str(" | ")?;
16593            }
16594            f.write_str("MAX")?;
16595            remaining &= !Self::MAX.0;
16596            first = false;
16597        }
16598        if remaining & Self::CENTERED.0 != 0 {
16599            if !first {
16600                f.write_str(" | ")?;
16601            }
16602            f.write_str("CENTERED")?;
16603            remaining &= !Self::CENTERED.0;
16604            first = false;
16605        }
16606        if remaining != 0u32 {
16607            if !first {
16608                f.write_str(" | ")?;
16609            }
16610            write!(f, "{:#x}", remaining)?;
16611        } else if first {
16612            f.write_str("(empty)")?;
16613        }
16614        Ok(())
16615    }
16616}
16617///[`VkPresentScalingFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentScalingFlagBitsKHR.html)
16618#[repr(transparent)]
16619#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
16620#[doc(alias = "VkPresentScalingFlagBitsKHR")]
16621pub struct PresentScalingFlagBitsKHR(u32);
16622impl PresentScalingFlagBitsKHR {
16623    #[inline]
16624    pub const fn empty() -> Self {
16625        Self(0u32)
16626    }
16627    #[inline]
16628    pub const fn from_raw(value: u32) -> Self {
16629        Self(value)
16630    }
16631    #[inline]
16632    pub const fn as_raw(self) -> u32 {
16633        self.0
16634    }
16635    #[inline]
16636    pub const fn is_empty(self) -> bool {
16637        self.0 == 0u32
16638    }
16639    #[inline]
16640    pub const fn contains(self, other: Self) -> bool {
16641        (self.0 & other.0) == other.0
16642    }
16643    #[inline]
16644    pub const fn all() -> Self {
16645        Self(7u32)
16646    }
16647    ///Bit 0.
16648    pub const ONE_TO_ONE: Self = Self(1u32);
16649    ///Bit 1.
16650    pub const ASPECT_RATIO_STRETCH: Self = Self(2u32);
16651    ///Bit 2.
16652    pub const STRETCH: Self = Self(4u32);
16653}
16654impl core::ops::BitOr for PresentScalingFlagBitsKHR {
16655    type Output = Self;
16656    #[inline]
16657    fn bitor(self, rhs: Self) -> Self {
16658        Self(self.0 | rhs.0)
16659    }
16660}
16661impl core::ops::BitOrAssign for PresentScalingFlagBitsKHR {
16662    #[inline]
16663    fn bitor_assign(&mut self, rhs: Self) {
16664        self.0 |= rhs.0;
16665    }
16666}
16667impl core::ops::BitAnd for PresentScalingFlagBitsKHR {
16668    type Output = Self;
16669    #[inline]
16670    fn bitand(self, rhs: Self) -> Self {
16671        Self(self.0 & rhs.0)
16672    }
16673}
16674impl core::ops::BitAndAssign for PresentScalingFlagBitsKHR {
16675    #[inline]
16676    fn bitand_assign(&mut self, rhs: Self) {
16677        self.0 &= rhs.0;
16678    }
16679}
16680impl core::ops::BitXor for PresentScalingFlagBitsKHR {
16681    type Output = Self;
16682    #[inline]
16683    fn bitxor(self, rhs: Self) -> Self {
16684        Self(self.0 ^ rhs.0)
16685    }
16686}
16687impl core::ops::BitXorAssign for PresentScalingFlagBitsKHR {
16688    #[inline]
16689    fn bitxor_assign(&mut self, rhs: Self) {
16690        self.0 ^= rhs.0;
16691    }
16692}
16693impl core::ops::Not for PresentScalingFlagBitsKHR {
16694    type Output = Self;
16695    #[inline]
16696    fn not(self) -> Self {
16697        Self(!self.0)
16698    }
16699}
16700impl core::fmt::Debug for PresentScalingFlagBitsKHR {
16701    #[allow(unused_mut, unused_variables)]
16702    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16703        let mut first = true;
16704        let mut remaining = self.0;
16705        if remaining & Self::ONE_TO_ONE.0 != 0 {
16706            if !first {
16707                f.write_str(" | ")?;
16708            }
16709            f.write_str("ONE_TO_ONE")?;
16710            remaining &= !Self::ONE_TO_ONE.0;
16711            first = false;
16712        }
16713        if remaining & Self::ASPECT_RATIO_STRETCH.0 != 0 {
16714            if !first {
16715                f.write_str(" | ")?;
16716            }
16717            f.write_str("ASPECT_RATIO_STRETCH")?;
16718            remaining &= !Self::ASPECT_RATIO_STRETCH.0;
16719            first = false;
16720        }
16721        if remaining & Self::STRETCH.0 != 0 {
16722            if !first {
16723                f.write_str(" | ")?;
16724            }
16725            f.write_str("STRETCH")?;
16726            remaining &= !Self::STRETCH.0;
16727            first = false;
16728        }
16729        if remaining != 0u32 {
16730            if !first {
16731                f.write_str(" | ")?;
16732            }
16733            write!(f, "{:#x}", remaining)?;
16734        } else if first {
16735            f.write_str("(empty)")?;
16736        }
16737        Ok(())
16738    }
16739}
16740///[`VkPresentStageFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageFlagBitsEXT.html)
16741#[repr(transparent)]
16742#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
16743#[doc(alias = "VkPresentStageFlagBitsEXT")]
16744pub struct PresentStageFlagBitsEXT(u32);
16745impl PresentStageFlagBitsEXT {
16746    #[inline]
16747    pub const fn empty() -> Self {
16748        Self(0u32)
16749    }
16750    #[inline]
16751    pub const fn from_raw(value: u32) -> Self {
16752        Self(value)
16753    }
16754    #[inline]
16755    pub const fn as_raw(self) -> u32 {
16756        self.0
16757    }
16758    #[inline]
16759    pub const fn is_empty(self) -> bool {
16760        self.0 == 0u32
16761    }
16762    #[inline]
16763    pub const fn contains(self, other: Self) -> bool {
16764        (self.0 & other.0) == other.0
16765    }
16766    #[inline]
16767    pub const fn all() -> Self {
16768        Self(15u32)
16769    }
16770    ///Bit 0.
16771    pub const QUEUE_OPERATIONS_END: Self = Self(1u32);
16772    ///Bit 1.
16773    pub const REQUEST_DEQUEUED: Self = Self(2u32);
16774    ///Bit 2.
16775    pub const IMAGE_FIRST_PIXEL_OUT: Self = Self(4u32);
16776    ///Bit 3.
16777    pub const IMAGE_FIRST_PIXEL_VISIBLE: Self = Self(8u32);
16778}
16779impl core::ops::BitOr for PresentStageFlagBitsEXT {
16780    type Output = Self;
16781    #[inline]
16782    fn bitor(self, rhs: Self) -> Self {
16783        Self(self.0 | rhs.0)
16784    }
16785}
16786impl core::ops::BitOrAssign for PresentStageFlagBitsEXT {
16787    #[inline]
16788    fn bitor_assign(&mut self, rhs: Self) {
16789        self.0 |= rhs.0;
16790    }
16791}
16792impl core::ops::BitAnd for PresentStageFlagBitsEXT {
16793    type Output = Self;
16794    #[inline]
16795    fn bitand(self, rhs: Self) -> Self {
16796        Self(self.0 & rhs.0)
16797    }
16798}
16799impl core::ops::BitAndAssign for PresentStageFlagBitsEXT {
16800    #[inline]
16801    fn bitand_assign(&mut self, rhs: Self) {
16802        self.0 &= rhs.0;
16803    }
16804}
16805impl core::ops::BitXor for PresentStageFlagBitsEXT {
16806    type Output = Self;
16807    #[inline]
16808    fn bitxor(self, rhs: Self) -> Self {
16809        Self(self.0 ^ rhs.0)
16810    }
16811}
16812impl core::ops::BitXorAssign for PresentStageFlagBitsEXT {
16813    #[inline]
16814    fn bitxor_assign(&mut self, rhs: Self) {
16815        self.0 ^= rhs.0;
16816    }
16817}
16818impl core::ops::Not for PresentStageFlagBitsEXT {
16819    type Output = Self;
16820    #[inline]
16821    fn not(self) -> Self {
16822        Self(!self.0)
16823    }
16824}
16825impl core::fmt::Debug for PresentStageFlagBitsEXT {
16826    #[allow(unused_mut, unused_variables)]
16827    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16828        let mut first = true;
16829        let mut remaining = self.0;
16830        if remaining & Self::QUEUE_OPERATIONS_END.0 != 0 {
16831            if !first {
16832                f.write_str(" | ")?;
16833            }
16834            f.write_str("QUEUE_OPERATIONS_END")?;
16835            remaining &= !Self::QUEUE_OPERATIONS_END.0;
16836            first = false;
16837        }
16838        if remaining & Self::REQUEST_DEQUEUED.0 != 0 {
16839            if !first {
16840                f.write_str(" | ")?;
16841            }
16842            f.write_str("REQUEST_DEQUEUED")?;
16843            remaining &= !Self::REQUEST_DEQUEUED.0;
16844            first = false;
16845        }
16846        if remaining & Self::IMAGE_FIRST_PIXEL_OUT.0 != 0 {
16847            if !first {
16848                f.write_str(" | ")?;
16849            }
16850            f.write_str("IMAGE_FIRST_PIXEL_OUT")?;
16851            remaining &= !Self::IMAGE_FIRST_PIXEL_OUT.0;
16852            first = false;
16853        }
16854        if remaining & Self::IMAGE_FIRST_PIXEL_VISIBLE.0 != 0 {
16855            if !first {
16856                f.write_str(" | ")?;
16857            }
16858            f.write_str("IMAGE_FIRST_PIXEL_VISIBLE")?;
16859            remaining &= !Self::IMAGE_FIRST_PIXEL_VISIBLE.0;
16860            first = false;
16861        }
16862        if remaining != 0u32 {
16863            if !first {
16864                f.write_str(" | ")?;
16865            }
16866            write!(f, "{:#x}", remaining)?;
16867        } else if first {
16868            f.write_str("(empty)")?;
16869        }
16870        Ok(())
16871    }
16872}
16873///[`VkPresentTimingInfoFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoFlagBitsEXT.html)
16874#[repr(transparent)]
16875#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
16876#[doc(alias = "VkPresentTimingInfoFlagBitsEXT")]
16877pub struct PresentTimingInfoFlagBitsEXT(u32);
16878impl PresentTimingInfoFlagBitsEXT {
16879    #[inline]
16880    pub const fn empty() -> Self {
16881        Self(0u32)
16882    }
16883    #[inline]
16884    pub const fn from_raw(value: u32) -> Self {
16885        Self(value)
16886    }
16887    #[inline]
16888    pub const fn as_raw(self) -> u32 {
16889        self.0
16890    }
16891    #[inline]
16892    pub const fn is_empty(self) -> bool {
16893        self.0 == 0u32
16894    }
16895    #[inline]
16896    pub const fn contains(self, other: Self) -> bool {
16897        (self.0 & other.0) == other.0
16898    }
16899    #[inline]
16900    pub const fn all() -> Self {
16901        Self(3u32)
16902    }
16903    ///Bit 0.
16904    pub const PRESENT_AT_RELATIVE_TIME: Self = Self(1u32);
16905    ///Bit 1.
16906    pub const PRESENT_AT_NEAREST_REFRESH_CYCLE: Self = Self(2u32);
16907}
16908impl core::ops::BitOr for PresentTimingInfoFlagBitsEXT {
16909    type Output = Self;
16910    #[inline]
16911    fn bitor(self, rhs: Self) -> Self {
16912        Self(self.0 | rhs.0)
16913    }
16914}
16915impl core::ops::BitOrAssign for PresentTimingInfoFlagBitsEXT {
16916    #[inline]
16917    fn bitor_assign(&mut self, rhs: Self) {
16918        self.0 |= rhs.0;
16919    }
16920}
16921impl core::ops::BitAnd for PresentTimingInfoFlagBitsEXT {
16922    type Output = Self;
16923    #[inline]
16924    fn bitand(self, rhs: Self) -> Self {
16925        Self(self.0 & rhs.0)
16926    }
16927}
16928impl core::ops::BitAndAssign for PresentTimingInfoFlagBitsEXT {
16929    #[inline]
16930    fn bitand_assign(&mut self, rhs: Self) {
16931        self.0 &= rhs.0;
16932    }
16933}
16934impl core::ops::BitXor for PresentTimingInfoFlagBitsEXT {
16935    type Output = Self;
16936    #[inline]
16937    fn bitxor(self, rhs: Self) -> Self {
16938        Self(self.0 ^ rhs.0)
16939    }
16940}
16941impl core::ops::BitXorAssign for PresentTimingInfoFlagBitsEXT {
16942    #[inline]
16943    fn bitxor_assign(&mut self, rhs: Self) {
16944        self.0 ^= rhs.0;
16945    }
16946}
16947impl core::ops::Not for PresentTimingInfoFlagBitsEXT {
16948    type Output = Self;
16949    #[inline]
16950    fn not(self) -> Self {
16951        Self(!self.0)
16952    }
16953}
16954impl core::fmt::Debug for PresentTimingInfoFlagBitsEXT {
16955    #[allow(unused_mut, unused_variables)]
16956    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16957        let mut first = true;
16958        let mut remaining = self.0;
16959        if remaining & Self::PRESENT_AT_RELATIVE_TIME.0 != 0 {
16960            if !first {
16961                f.write_str(" | ")?;
16962            }
16963            f.write_str("PRESENT_AT_RELATIVE_TIME")?;
16964            remaining &= !Self::PRESENT_AT_RELATIVE_TIME.0;
16965            first = false;
16966        }
16967        if remaining & Self::PRESENT_AT_NEAREST_REFRESH_CYCLE.0 != 0 {
16968            if !first {
16969                f.write_str(" | ")?;
16970            }
16971            f.write_str("PRESENT_AT_NEAREST_REFRESH_CYCLE")?;
16972            remaining &= !Self::PRESENT_AT_NEAREST_REFRESH_CYCLE.0;
16973            first = false;
16974        }
16975        if remaining != 0u32 {
16976            if !first {
16977                f.write_str(" | ")?;
16978            }
16979            write!(f, "{:#x}", remaining)?;
16980        } else if first {
16981            f.write_str("(empty)")?;
16982        }
16983        Ok(())
16984    }
16985}
16986///[`VkPrivateDataSlotCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateFlagBits.html)
16987#[repr(transparent)]
16988#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
16989#[doc(alias = "VkPrivateDataSlotCreateFlagBits")]
16990pub struct PrivateDataSlotCreateFlagBits(u32);
16991impl PrivateDataSlotCreateFlagBits {
16992    #[inline]
16993    pub const fn empty() -> Self {
16994        Self(0u32)
16995    }
16996    #[inline]
16997    pub const fn from_raw(value: u32) -> Self {
16998        Self(value)
16999    }
17000    #[inline]
17001    pub const fn as_raw(self) -> u32 {
17002        self.0
17003    }
17004    #[inline]
17005    pub const fn is_empty(self) -> bool {
17006        self.0 == 0u32
17007    }
17008    #[inline]
17009    pub const fn contains(self, other: Self) -> bool {
17010        (self.0 & other.0) == other.0
17011    }
17012    #[inline]
17013    pub const fn all() -> Self {
17014        Self(0u32)
17015    }
17016}
17017impl core::ops::BitOr for PrivateDataSlotCreateFlagBits {
17018    type Output = Self;
17019    #[inline]
17020    fn bitor(self, rhs: Self) -> Self {
17021        Self(self.0 | rhs.0)
17022    }
17023}
17024impl core::ops::BitOrAssign for PrivateDataSlotCreateFlagBits {
17025    #[inline]
17026    fn bitor_assign(&mut self, rhs: Self) {
17027        self.0 |= rhs.0;
17028    }
17029}
17030impl core::ops::BitAnd for PrivateDataSlotCreateFlagBits {
17031    type Output = Self;
17032    #[inline]
17033    fn bitand(self, rhs: Self) -> Self {
17034        Self(self.0 & rhs.0)
17035    }
17036}
17037impl core::ops::BitAndAssign for PrivateDataSlotCreateFlagBits {
17038    #[inline]
17039    fn bitand_assign(&mut self, rhs: Self) {
17040        self.0 &= rhs.0;
17041    }
17042}
17043impl core::ops::BitXor for PrivateDataSlotCreateFlagBits {
17044    type Output = Self;
17045    #[inline]
17046    fn bitxor(self, rhs: Self) -> Self {
17047        Self(self.0 ^ rhs.0)
17048    }
17049}
17050impl core::ops::BitXorAssign for PrivateDataSlotCreateFlagBits {
17051    #[inline]
17052    fn bitxor_assign(&mut self, rhs: Self) {
17053        self.0 ^= rhs.0;
17054    }
17055}
17056impl core::ops::Not for PrivateDataSlotCreateFlagBits {
17057    type Output = Self;
17058    #[inline]
17059    fn not(self) -> Self {
17060        Self(!self.0)
17061    }
17062}
17063impl core::fmt::Debug for PrivateDataSlotCreateFlagBits {
17064    #[allow(unused_mut, unused_variables)]
17065    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17066        let mut first = true;
17067        let mut remaining = self.0;
17068        if remaining != 0u32 {
17069            if !first {
17070                f.write_str(" | ")?;
17071            }
17072            write!(f, "{:#x}", remaining)?;
17073        } else if first {
17074            f.write_str("(empty)")?;
17075        }
17076        Ok(())
17077    }
17078}
17079///[`VkQueryControlFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryControlFlagBits.html)
17080#[repr(transparent)]
17081#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
17082#[doc(alias = "VkQueryControlFlagBits")]
17083pub struct QueryControlFlagBits(u32);
17084impl QueryControlFlagBits {
17085    #[inline]
17086    pub const fn empty() -> Self {
17087        Self(0u32)
17088    }
17089    #[inline]
17090    pub const fn from_raw(value: u32) -> Self {
17091        Self(value)
17092    }
17093    #[inline]
17094    pub const fn as_raw(self) -> u32 {
17095        self.0
17096    }
17097    #[inline]
17098    pub const fn is_empty(self) -> bool {
17099        self.0 == 0u32
17100    }
17101    #[inline]
17102    pub const fn contains(self, other: Self) -> bool {
17103        (self.0 & other.0) == other.0
17104    }
17105    #[inline]
17106    pub const fn all() -> Self {
17107        Self(1u32)
17108    }
17109    ///Bit 0.
17110    pub const PRECISE: Self = Self(1u32);
17111}
17112impl core::ops::BitOr for QueryControlFlagBits {
17113    type Output = Self;
17114    #[inline]
17115    fn bitor(self, rhs: Self) -> Self {
17116        Self(self.0 | rhs.0)
17117    }
17118}
17119impl core::ops::BitOrAssign for QueryControlFlagBits {
17120    #[inline]
17121    fn bitor_assign(&mut self, rhs: Self) {
17122        self.0 |= rhs.0;
17123    }
17124}
17125impl core::ops::BitAnd for QueryControlFlagBits {
17126    type Output = Self;
17127    #[inline]
17128    fn bitand(self, rhs: Self) -> Self {
17129        Self(self.0 & rhs.0)
17130    }
17131}
17132impl core::ops::BitAndAssign for QueryControlFlagBits {
17133    #[inline]
17134    fn bitand_assign(&mut self, rhs: Self) {
17135        self.0 &= rhs.0;
17136    }
17137}
17138impl core::ops::BitXor for QueryControlFlagBits {
17139    type Output = Self;
17140    #[inline]
17141    fn bitxor(self, rhs: Self) -> Self {
17142        Self(self.0 ^ rhs.0)
17143    }
17144}
17145impl core::ops::BitXorAssign for QueryControlFlagBits {
17146    #[inline]
17147    fn bitxor_assign(&mut self, rhs: Self) {
17148        self.0 ^= rhs.0;
17149    }
17150}
17151impl core::ops::Not for QueryControlFlagBits {
17152    type Output = Self;
17153    #[inline]
17154    fn not(self) -> Self {
17155        Self(!self.0)
17156    }
17157}
17158impl core::fmt::Debug for QueryControlFlagBits {
17159    #[allow(unused_mut, unused_variables)]
17160    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17161        let mut first = true;
17162        let mut remaining = self.0;
17163        if remaining & Self::PRECISE.0 != 0 {
17164            if !first {
17165                f.write_str(" | ")?;
17166            }
17167            f.write_str("PRECISE")?;
17168            remaining &= !Self::PRECISE.0;
17169            first = false;
17170        }
17171        if remaining != 0u32 {
17172            if !first {
17173                f.write_str(" | ")?;
17174            }
17175            write!(f, "{:#x}", remaining)?;
17176        } else if first {
17177            f.write_str("(empty)")?;
17178        }
17179        Ok(())
17180    }
17181}
17182///[`VkQueryPipelineStatisticFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPipelineStatisticFlagBits.html)
17183#[repr(transparent)]
17184#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
17185#[doc(alias = "VkQueryPipelineStatisticFlagBits")]
17186pub struct QueryPipelineStatisticFlagBits(u32);
17187impl QueryPipelineStatisticFlagBits {
17188    #[inline]
17189    pub const fn empty() -> Self {
17190        Self(0u32)
17191    }
17192    #[inline]
17193    pub const fn from_raw(value: u32) -> Self {
17194        Self(value)
17195    }
17196    #[inline]
17197    pub const fn as_raw(self) -> u32 {
17198        self.0
17199    }
17200    #[inline]
17201    pub const fn is_empty(self) -> bool {
17202        self.0 == 0u32
17203    }
17204    #[inline]
17205    pub const fn contains(self, other: Self) -> bool {
17206        (self.0 & other.0) == other.0
17207    }
17208    #[inline]
17209    pub const fn all() -> Self {
17210        Self(16383u32)
17211    }
17212    ///Bit 0.
17213    pub const INPUT_ASSEMBLY_VERTICES: Self = Self(1u32);
17214    ///Bit 1.
17215    pub const INPUT_ASSEMBLY_PRIMITIVES: Self = Self(2u32);
17216    ///Bit 2.
17217    pub const VERTEX_SHADER_INVOCATIONS: Self = Self(4u32);
17218    ///Bit 3.
17219    pub const GEOMETRY_SHADER_INVOCATIONS: Self = Self(8u32);
17220    ///Bit 4.
17221    pub const GEOMETRY_SHADER_PRIMITIVES: Self = Self(16u32);
17222    ///Bit 5.
17223    pub const CLIPPING_INVOCATIONS: Self = Self(32u32);
17224    ///Bit 6.
17225    pub const CLIPPING_PRIMITIVES: Self = Self(64u32);
17226    ///Bit 7.
17227    pub const FRAGMENT_SHADER_INVOCATIONS: Self = Self(128u32);
17228    ///Bit 8.
17229    pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = Self(256u32);
17230    ///Bit 9.
17231    pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = Self(512u32);
17232    ///Bit 10.
17233    pub const COMPUTE_SHADER_INVOCATIONS: Self = Self(1024u32);
17234    ///Bit 11.
17235    pub const TASK_SHADER_INVOCATIONS: Self = Self(2048u32);
17236    ///Bit 12.
17237    pub const MESH_SHADER_INVOCATIONS: Self = Self(4096u32);
17238    ///Bit 13.
17239    pub const CLUSTER_CULLING_SHADER_INVOCATIONS_BIT: Self = Self(8192u32);
17240}
17241impl core::ops::BitOr for QueryPipelineStatisticFlagBits {
17242    type Output = Self;
17243    #[inline]
17244    fn bitor(self, rhs: Self) -> Self {
17245        Self(self.0 | rhs.0)
17246    }
17247}
17248impl core::ops::BitOrAssign for QueryPipelineStatisticFlagBits {
17249    #[inline]
17250    fn bitor_assign(&mut self, rhs: Self) {
17251        self.0 |= rhs.0;
17252    }
17253}
17254impl core::ops::BitAnd for QueryPipelineStatisticFlagBits {
17255    type Output = Self;
17256    #[inline]
17257    fn bitand(self, rhs: Self) -> Self {
17258        Self(self.0 & rhs.0)
17259    }
17260}
17261impl core::ops::BitAndAssign for QueryPipelineStatisticFlagBits {
17262    #[inline]
17263    fn bitand_assign(&mut self, rhs: Self) {
17264        self.0 &= rhs.0;
17265    }
17266}
17267impl core::ops::BitXor for QueryPipelineStatisticFlagBits {
17268    type Output = Self;
17269    #[inline]
17270    fn bitxor(self, rhs: Self) -> Self {
17271        Self(self.0 ^ rhs.0)
17272    }
17273}
17274impl core::ops::BitXorAssign for QueryPipelineStatisticFlagBits {
17275    #[inline]
17276    fn bitxor_assign(&mut self, rhs: Self) {
17277        self.0 ^= rhs.0;
17278    }
17279}
17280impl core::ops::Not for QueryPipelineStatisticFlagBits {
17281    type Output = Self;
17282    #[inline]
17283    fn not(self) -> Self {
17284        Self(!self.0)
17285    }
17286}
17287impl core::fmt::Debug for QueryPipelineStatisticFlagBits {
17288    #[allow(unused_mut, unused_variables)]
17289    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17290        let mut first = true;
17291        let mut remaining = self.0;
17292        if remaining & Self::INPUT_ASSEMBLY_VERTICES.0 != 0 {
17293            if !first {
17294                f.write_str(" | ")?;
17295            }
17296            f.write_str("INPUT_ASSEMBLY_VERTICES")?;
17297            remaining &= !Self::INPUT_ASSEMBLY_VERTICES.0;
17298            first = false;
17299        }
17300        if remaining & Self::INPUT_ASSEMBLY_PRIMITIVES.0 != 0 {
17301            if !first {
17302                f.write_str(" | ")?;
17303            }
17304            f.write_str("INPUT_ASSEMBLY_PRIMITIVES")?;
17305            remaining &= !Self::INPUT_ASSEMBLY_PRIMITIVES.0;
17306            first = false;
17307        }
17308        if remaining & Self::VERTEX_SHADER_INVOCATIONS.0 != 0 {
17309            if !first {
17310                f.write_str(" | ")?;
17311            }
17312            f.write_str("VERTEX_SHADER_INVOCATIONS")?;
17313            remaining &= !Self::VERTEX_SHADER_INVOCATIONS.0;
17314            first = false;
17315        }
17316        if remaining & Self::GEOMETRY_SHADER_INVOCATIONS.0 != 0 {
17317            if !first {
17318                f.write_str(" | ")?;
17319            }
17320            f.write_str("GEOMETRY_SHADER_INVOCATIONS")?;
17321            remaining &= !Self::GEOMETRY_SHADER_INVOCATIONS.0;
17322            first = false;
17323        }
17324        if remaining & Self::GEOMETRY_SHADER_PRIMITIVES.0 != 0 {
17325            if !first {
17326                f.write_str(" | ")?;
17327            }
17328            f.write_str("GEOMETRY_SHADER_PRIMITIVES")?;
17329            remaining &= !Self::GEOMETRY_SHADER_PRIMITIVES.0;
17330            first = false;
17331        }
17332        if remaining & Self::CLIPPING_INVOCATIONS.0 != 0 {
17333            if !first {
17334                f.write_str(" | ")?;
17335            }
17336            f.write_str("CLIPPING_INVOCATIONS")?;
17337            remaining &= !Self::CLIPPING_INVOCATIONS.0;
17338            first = false;
17339        }
17340        if remaining & Self::CLIPPING_PRIMITIVES.0 != 0 {
17341            if !first {
17342                f.write_str(" | ")?;
17343            }
17344            f.write_str("CLIPPING_PRIMITIVES")?;
17345            remaining &= !Self::CLIPPING_PRIMITIVES.0;
17346            first = false;
17347        }
17348        if remaining & Self::FRAGMENT_SHADER_INVOCATIONS.0 != 0 {
17349            if !first {
17350                f.write_str(" | ")?;
17351            }
17352            f.write_str("FRAGMENT_SHADER_INVOCATIONS")?;
17353            remaining &= !Self::FRAGMENT_SHADER_INVOCATIONS.0;
17354            first = false;
17355        }
17356        if remaining & Self::TESSELLATION_CONTROL_SHADER_PATCHES.0 != 0 {
17357            if !first {
17358                f.write_str(" | ")?;
17359            }
17360            f.write_str("TESSELLATION_CONTROL_SHADER_PATCHES")?;
17361            remaining &= !Self::TESSELLATION_CONTROL_SHADER_PATCHES.0;
17362            first = false;
17363        }
17364        if remaining & Self::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0 != 0 {
17365            if !first {
17366                f.write_str(" | ")?;
17367            }
17368            f.write_str("TESSELLATION_EVALUATION_SHADER_INVOCATIONS")?;
17369            remaining &= !Self::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0;
17370            first = false;
17371        }
17372        if remaining & Self::COMPUTE_SHADER_INVOCATIONS.0 != 0 {
17373            if !first {
17374                f.write_str(" | ")?;
17375            }
17376            f.write_str("COMPUTE_SHADER_INVOCATIONS")?;
17377            remaining &= !Self::COMPUTE_SHADER_INVOCATIONS.0;
17378            first = false;
17379        }
17380        if remaining & Self::TASK_SHADER_INVOCATIONS.0 != 0 {
17381            if !first {
17382                f.write_str(" | ")?;
17383            }
17384            f.write_str("TASK_SHADER_INVOCATIONS")?;
17385            remaining &= !Self::TASK_SHADER_INVOCATIONS.0;
17386            first = false;
17387        }
17388        if remaining & Self::MESH_SHADER_INVOCATIONS.0 != 0 {
17389            if !first {
17390                f.write_str(" | ")?;
17391            }
17392            f.write_str("MESH_SHADER_INVOCATIONS")?;
17393            remaining &= !Self::MESH_SHADER_INVOCATIONS.0;
17394            first = false;
17395        }
17396        if remaining & Self::CLUSTER_CULLING_SHADER_INVOCATIONS_BIT.0 != 0 {
17397            if !first {
17398                f.write_str(" | ")?;
17399            }
17400            f.write_str("CLUSTER_CULLING_SHADER_INVOCATIONS_BIT")?;
17401            remaining &= !Self::CLUSTER_CULLING_SHADER_INVOCATIONS_BIT.0;
17402            first = false;
17403        }
17404        if remaining != 0u32 {
17405            if !first {
17406                f.write_str(" | ")?;
17407            }
17408            write!(f, "{:#x}", remaining)?;
17409        } else if first {
17410            f.write_str("(empty)")?;
17411        }
17412        Ok(())
17413    }
17414}
17415///[`VkQueryPoolCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateFlagBits.html)
17416#[repr(transparent)]
17417#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
17418#[doc(alias = "VkQueryPoolCreateFlagBits")]
17419pub struct QueryPoolCreateFlagBits(u32);
17420impl QueryPoolCreateFlagBits {
17421    #[inline]
17422    pub const fn empty() -> Self {
17423        Self(0u32)
17424    }
17425    #[inline]
17426    pub const fn from_raw(value: u32) -> Self {
17427        Self(value)
17428    }
17429    #[inline]
17430    pub const fn as_raw(self) -> u32 {
17431        self.0
17432    }
17433    #[inline]
17434    pub const fn is_empty(self) -> bool {
17435        self.0 == 0u32
17436    }
17437    #[inline]
17438    pub const fn contains(self, other: Self) -> bool {
17439        (self.0 & other.0) == other.0
17440    }
17441    #[inline]
17442    pub const fn all() -> Self {
17443        Self(1u32)
17444    }
17445    ///Bit 0.
17446    pub const RESET: Self = Self(1u32);
17447}
17448impl core::ops::BitOr for QueryPoolCreateFlagBits {
17449    type Output = Self;
17450    #[inline]
17451    fn bitor(self, rhs: Self) -> Self {
17452        Self(self.0 | rhs.0)
17453    }
17454}
17455impl core::ops::BitOrAssign for QueryPoolCreateFlagBits {
17456    #[inline]
17457    fn bitor_assign(&mut self, rhs: Self) {
17458        self.0 |= rhs.0;
17459    }
17460}
17461impl core::ops::BitAnd for QueryPoolCreateFlagBits {
17462    type Output = Self;
17463    #[inline]
17464    fn bitand(self, rhs: Self) -> Self {
17465        Self(self.0 & rhs.0)
17466    }
17467}
17468impl core::ops::BitAndAssign for QueryPoolCreateFlagBits {
17469    #[inline]
17470    fn bitand_assign(&mut self, rhs: Self) {
17471        self.0 &= rhs.0;
17472    }
17473}
17474impl core::ops::BitXor for QueryPoolCreateFlagBits {
17475    type Output = Self;
17476    #[inline]
17477    fn bitxor(self, rhs: Self) -> Self {
17478        Self(self.0 ^ rhs.0)
17479    }
17480}
17481impl core::ops::BitXorAssign for QueryPoolCreateFlagBits {
17482    #[inline]
17483    fn bitxor_assign(&mut self, rhs: Self) {
17484        self.0 ^= rhs.0;
17485    }
17486}
17487impl core::ops::Not for QueryPoolCreateFlagBits {
17488    type Output = Self;
17489    #[inline]
17490    fn not(self) -> Self {
17491        Self(!self.0)
17492    }
17493}
17494impl core::fmt::Debug for QueryPoolCreateFlagBits {
17495    #[allow(unused_mut, unused_variables)]
17496    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17497        let mut first = true;
17498        let mut remaining = self.0;
17499        if remaining & Self::RESET.0 != 0 {
17500            if !first {
17501                f.write_str(" | ")?;
17502            }
17503            f.write_str("RESET")?;
17504            remaining &= !Self::RESET.0;
17505            first = false;
17506        }
17507        if remaining != 0u32 {
17508            if !first {
17509                f.write_str(" | ")?;
17510            }
17511            write!(f, "{:#x}", remaining)?;
17512        } else if first {
17513            f.write_str("(empty)")?;
17514        }
17515        Ok(())
17516    }
17517}
17518///[`VkQueryResultFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultFlagBits.html)
17519#[repr(transparent)]
17520#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
17521#[doc(alias = "VkQueryResultFlagBits")]
17522pub struct QueryResultFlagBits(u32);
17523impl QueryResultFlagBits {
17524    #[inline]
17525    pub const fn empty() -> Self {
17526        Self(0u32)
17527    }
17528    #[inline]
17529    pub const fn from_raw(value: u32) -> Self {
17530        Self(value)
17531    }
17532    #[inline]
17533    pub const fn as_raw(self) -> u32 {
17534        self.0
17535    }
17536    #[inline]
17537    pub const fn is_empty(self) -> bool {
17538        self.0 == 0u32
17539    }
17540    #[inline]
17541    pub const fn contains(self, other: Self) -> bool {
17542        (self.0 & other.0) == other.0
17543    }
17544    #[inline]
17545    pub const fn all() -> Self {
17546        Self(31u32)
17547    }
17548    ///Bit 0.
17549    pub const _64: Self = Self(1u32);
17550    ///Bit 1.
17551    pub const WAIT: Self = Self(2u32);
17552    ///Bit 2.
17553    pub const WITH_AVAILABILITY: Self = Self(4u32);
17554    ///Bit 3.
17555    pub const PARTIAL: Self = Self(8u32);
17556    ///Bit 4.
17557    pub const WITH_STATUS: Self = Self(16u32);
17558}
17559impl core::ops::BitOr for QueryResultFlagBits {
17560    type Output = Self;
17561    #[inline]
17562    fn bitor(self, rhs: Self) -> Self {
17563        Self(self.0 | rhs.0)
17564    }
17565}
17566impl core::ops::BitOrAssign for QueryResultFlagBits {
17567    #[inline]
17568    fn bitor_assign(&mut self, rhs: Self) {
17569        self.0 |= rhs.0;
17570    }
17571}
17572impl core::ops::BitAnd for QueryResultFlagBits {
17573    type Output = Self;
17574    #[inline]
17575    fn bitand(self, rhs: Self) -> Self {
17576        Self(self.0 & rhs.0)
17577    }
17578}
17579impl core::ops::BitAndAssign for QueryResultFlagBits {
17580    #[inline]
17581    fn bitand_assign(&mut self, rhs: Self) {
17582        self.0 &= rhs.0;
17583    }
17584}
17585impl core::ops::BitXor for QueryResultFlagBits {
17586    type Output = Self;
17587    #[inline]
17588    fn bitxor(self, rhs: Self) -> Self {
17589        Self(self.0 ^ rhs.0)
17590    }
17591}
17592impl core::ops::BitXorAssign for QueryResultFlagBits {
17593    #[inline]
17594    fn bitxor_assign(&mut self, rhs: Self) {
17595        self.0 ^= rhs.0;
17596    }
17597}
17598impl core::ops::Not for QueryResultFlagBits {
17599    type Output = Self;
17600    #[inline]
17601    fn not(self) -> Self {
17602        Self(!self.0)
17603    }
17604}
17605impl core::fmt::Debug for QueryResultFlagBits {
17606    #[allow(unused_mut, unused_variables)]
17607    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17608        let mut first = true;
17609        let mut remaining = self.0;
17610        if remaining & Self::_64.0 != 0 {
17611            if !first {
17612                f.write_str(" | ")?;
17613            }
17614            f.write_str("_64")?;
17615            remaining &= !Self::_64.0;
17616            first = false;
17617        }
17618        if remaining & Self::WAIT.0 != 0 {
17619            if !first {
17620                f.write_str(" | ")?;
17621            }
17622            f.write_str("WAIT")?;
17623            remaining &= !Self::WAIT.0;
17624            first = false;
17625        }
17626        if remaining & Self::WITH_AVAILABILITY.0 != 0 {
17627            if !first {
17628                f.write_str(" | ")?;
17629            }
17630            f.write_str("WITH_AVAILABILITY")?;
17631            remaining &= !Self::WITH_AVAILABILITY.0;
17632            first = false;
17633        }
17634        if remaining & Self::PARTIAL.0 != 0 {
17635            if !first {
17636                f.write_str(" | ")?;
17637            }
17638            f.write_str("PARTIAL")?;
17639            remaining &= !Self::PARTIAL.0;
17640            first = false;
17641        }
17642        if remaining & Self::WITH_STATUS.0 != 0 {
17643            if !first {
17644                f.write_str(" | ")?;
17645            }
17646            f.write_str("WITH_STATUS")?;
17647            remaining &= !Self::WITH_STATUS.0;
17648            first = false;
17649        }
17650        if remaining != 0u32 {
17651            if !first {
17652                f.write_str(" | ")?;
17653            }
17654            write!(f, "{:#x}", remaining)?;
17655        } else if first {
17656            f.write_str("(empty)")?;
17657        }
17658        Ok(())
17659    }
17660}
17661///[`VkQueueFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFlagBits.html)
17662#[repr(transparent)]
17663#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
17664#[doc(alias = "VkQueueFlagBits")]
17665pub struct QueueFlagBits(u32);
17666impl QueueFlagBits {
17667    #[inline]
17668    pub const fn empty() -> Self {
17669        Self(0u32)
17670    }
17671    #[inline]
17672    pub const fn from_raw(value: u32) -> Self {
17673        Self(value)
17674    }
17675    #[inline]
17676    pub const fn as_raw(self) -> u32 {
17677        self.0
17678    }
17679    #[inline]
17680    pub const fn is_empty(self) -> bool {
17681        self.0 == 0u32
17682    }
17683    #[inline]
17684    pub const fn contains(self, other: Self) -> bool {
17685        (self.0 & other.0) == other.0
17686    }
17687    #[inline]
17688    pub const fn all() -> Self {
17689        Self(1407u32)
17690    }
17691    ///Bit 0.
17692    pub const GRAPHICS: Self = Self(1u32);
17693    ///Bit 1.
17694    pub const COMPUTE: Self = Self(2u32);
17695    ///Bit 2.
17696    pub const TRANSFER: Self = Self(4u32);
17697    ///Bit 3.
17698    pub const SPARSE_BINDING: Self = Self(8u32);
17699    ///Bit 4.
17700    pub const PROTECTED: Self = Self(16u32);
17701    ///Bit 5.
17702    pub const VIDEO_DECODE: Self = Self(32u32);
17703    ///Bit 6.
17704    pub const VIDEO_ENCODE: Self = Self(64u32);
17705    ///Bit 8.
17706    pub const OPTICAL_FLOW: Self = Self(256u32);
17707    ///Bit 10.
17708    pub const DATA_GRAPH_BIT: Self = Self(1024u32);
17709}
17710impl core::ops::BitOr for QueueFlagBits {
17711    type Output = Self;
17712    #[inline]
17713    fn bitor(self, rhs: Self) -> Self {
17714        Self(self.0 | rhs.0)
17715    }
17716}
17717impl core::ops::BitOrAssign for QueueFlagBits {
17718    #[inline]
17719    fn bitor_assign(&mut self, rhs: Self) {
17720        self.0 |= rhs.0;
17721    }
17722}
17723impl core::ops::BitAnd for QueueFlagBits {
17724    type Output = Self;
17725    #[inline]
17726    fn bitand(self, rhs: Self) -> Self {
17727        Self(self.0 & rhs.0)
17728    }
17729}
17730impl core::ops::BitAndAssign for QueueFlagBits {
17731    #[inline]
17732    fn bitand_assign(&mut self, rhs: Self) {
17733        self.0 &= rhs.0;
17734    }
17735}
17736impl core::ops::BitXor for QueueFlagBits {
17737    type Output = Self;
17738    #[inline]
17739    fn bitxor(self, rhs: Self) -> Self {
17740        Self(self.0 ^ rhs.0)
17741    }
17742}
17743impl core::ops::BitXorAssign for QueueFlagBits {
17744    #[inline]
17745    fn bitxor_assign(&mut self, rhs: Self) {
17746        self.0 ^= rhs.0;
17747    }
17748}
17749impl core::ops::Not for QueueFlagBits {
17750    type Output = Self;
17751    #[inline]
17752    fn not(self) -> Self {
17753        Self(!self.0)
17754    }
17755}
17756impl core::fmt::Debug for QueueFlagBits {
17757    #[allow(unused_mut, unused_variables)]
17758    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17759        let mut first = true;
17760        let mut remaining = self.0;
17761        if remaining & Self::GRAPHICS.0 != 0 {
17762            if !first {
17763                f.write_str(" | ")?;
17764            }
17765            f.write_str("GRAPHICS")?;
17766            remaining &= !Self::GRAPHICS.0;
17767            first = false;
17768        }
17769        if remaining & Self::COMPUTE.0 != 0 {
17770            if !first {
17771                f.write_str(" | ")?;
17772            }
17773            f.write_str("COMPUTE")?;
17774            remaining &= !Self::COMPUTE.0;
17775            first = false;
17776        }
17777        if remaining & Self::TRANSFER.0 != 0 {
17778            if !first {
17779                f.write_str(" | ")?;
17780            }
17781            f.write_str("TRANSFER")?;
17782            remaining &= !Self::TRANSFER.0;
17783            first = false;
17784        }
17785        if remaining & Self::SPARSE_BINDING.0 != 0 {
17786            if !first {
17787                f.write_str(" | ")?;
17788            }
17789            f.write_str("SPARSE_BINDING")?;
17790            remaining &= !Self::SPARSE_BINDING.0;
17791            first = false;
17792        }
17793        if remaining & Self::PROTECTED.0 != 0 {
17794            if !first {
17795                f.write_str(" | ")?;
17796            }
17797            f.write_str("PROTECTED")?;
17798            remaining &= !Self::PROTECTED.0;
17799            first = false;
17800        }
17801        if remaining & Self::VIDEO_DECODE.0 != 0 {
17802            if !first {
17803                f.write_str(" | ")?;
17804            }
17805            f.write_str("VIDEO_DECODE")?;
17806            remaining &= !Self::VIDEO_DECODE.0;
17807            first = false;
17808        }
17809        if remaining & Self::VIDEO_ENCODE.0 != 0 {
17810            if !first {
17811                f.write_str(" | ")?;
17812            }
17813            f.write_str("VIDEO_ENCODE")?;
17814            remaining &= !Self::VIDEO_ENCODE.0;
17815            first = false;
17816        }
17817        if remaining & Self::OPTICAL_FLOW.0 != 0 {
17818            if !first {
17819                f.write_str(" | ")?;
17820            }
17821            f.write_str("OPTICAL_FLOW")?;
17822            remaining &= !Self::OPTICAL_FLOW.0;
17823            first = false;
17824        }
17825        if remaining & Self::DATA_GRAPH_BIT.0 != 0 {
17826            if !first {
17827                f.write_str(" | ")?;
17828            }
17829            f.write_str("DATA_GRAPH_BIT")?;
17830            remaining &= !Self::DATA_GRAPH_BIT.0;
17831            first = false;
17832        }
17833        if remaining != 0u32 {
17834            if !first {
17835                f.write_str(" | ")?;
17836            }
17837            write!(f, "{:#x}", remaining)?;
17838        } else if first {
17839            f.write_str("(empty)")?;
17840        }
17841        Ok(())
17842    }
17843}
17844///[`VkRefreshObjectFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRefreshObjectFlagBitsKHR.html)
17845#[repr(transparent)]
17846#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
17847#[doc(alias = "VkRefreshObjectFlagBitsKHR")]
17848pub struct RefreshObjectFlagBitsKHR(u32);
17849impl RefreshObjectFlagBitsKHR {
17850    #[inline]
17851    pub const fn empty() -> Self {
17852        Self(0u32)
17853    }
17854    #[inline]
17855    pub const fn from_raw(value: u32) -> Self {
17856        Self(value)
17857    }
17858    #[inline]
17859    pub const fn as_raw(self) -> u32 {
17860        self.0
17861    }
17862    #[inline]
17863    pub const fn is_empty(self) -> bool {
17864        self.0 == 0u32
17865    }
17866    #[inline]
17867    pub const fn contains(self, other: Self) -> bool {
17868        (self.0 & other.0) == other.0
17869    }
17870    #[inline]
17871    pub const fn all() -> Self {
17872        Self(0u32)
17873    }
17874}
17875impl core::ops::BitOr for RefreshObjectFlagBitsKHR {
17876    type Output = Self;
17877    #[inline]
17878    fn bitor(self, rhs: Self) -> Self {
17879        Self(self.0 | rhs.0)
17880    }
17881}
17882impl core::ops::BitOrAssign for RefreshObjectFlagBitsKHR {
17883    #[inline]
17884    fn bitor_assign(&mut self, rhs: Self) {
17885        self.0 |= rhs.0;
17886    }
17887}
17888impl core::ops::BitAnd for RefreshObjectFlagBitsKHR {
17889    type Output = Self;
17890    #[inline]
17891    fn bitand(self, rhs: Self) -> Self {
17892        Self(self.0 & rhs.0)
17893    }
17894}
17895impl core::ops::BitAndAssign for RefreshObjectFlagBitsKHR {
17896    #[inline]
17897    fn bitand_assign(&mut self, rhs: Self) {
17898        self.0 &= rhs.0;
17899    }
17900}
17901impl core::ops::BitXor for RefreshObjectFlagBitsKHR {
17902    type Output = Self;
17903    #[inline]
17904    fn bitxor(self, rhs: Self) -> Self {
17905        Self(self.0 ^ rhs.0)
17906    }
17907}
17908impl core::ops::BitXorAssign for RefreshObjectFlagBitsKHR {
17909    #[inline]
17910    fn bitxor_assign(&mut self, rhs: Self) {
17911        self.0 ^= rhs.0;
17912    }
17913}
17914impl core::ops::Not for RefreshObjectFlagBitsKHR {
17915    type Output = Self;
17916    #[inline]
17917    fn not(self) -> Self {
17918        Self(!self.0)
17919    }
17920}
17921impl core::fmt::Debug for RefreshObjectFlagBitsKHR {
17922    #[allow(unused_mut, unused_variables)]
17923    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17924        let mut first = true;
17925        let mut remaining = self.0;
17926        if remaining != 0u32 {
17927            if !first {
17928                f.write_str(" | ")?;
17929            }
17930            write!(f, "{:#x}", remaining)?;
17931        } else if first {
17932            f.write_str("(empty)")?;
17933        }
17934        Ok(())
17935    }
17936}
17937///[`VkRenderPassCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateFlagBits.html)
17938#[repr(transparent)]
17939#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
17940#[doc(alias = "VkRenderPassCreateFlagBits")]
17941pub struct RenderPassCreateFlagBits(u32);
17942impl RenderPassCreateFlagBits {
17943    #[inline]
17944    pub const fn empty() -> Self {
17945        Self(0u32)
17946    }
17947    #[inline]
17948    pub const fn from_raw(value: u32) -> Self {
17949        Self(value)
17950    }
17951    #[inline]
17952    pub const fn as_raw(self) -> u32 {
17953        self.0
17954    }
17955    #[inline]
17956    pub const fn is_empty(self) -> bool {
17957        self.0 == 0u32
17958    }
17959    #[inline]
17960    pub const fn contains(self, other: Self) -> bool {
17961        (self.0 & other.0) == other.0
17962    }
17963    #[inline]
17964    pub const fn all() -> Self {
17965        Self(6u32)
17966    }
17967    ///Bit 1.
17968    pub const TRANSFORM_BIT: Self = Self(2u32);
17969    ///Bit 2.
17970    pub const PER_LAYER_FRAGMENT_DENSITY_BIT: Self = Self(4u32);
17971}
17972impl core::ops::BitOr for RenderPassCreateFlagBits {
17973    type Output = Self;
17974    #[inline]
17975    fn bitor(self, rhs: Self) -> Self {
17976        Self(self.0 | rhs.0)
17977    }
17978}
17979impl core::ops::BitOrAssign for RenderPassCreateFlagBits {
17980    #[inline]
17981    fn bitor_assign(&mut self, rhs: Self) {
17982        self.0 |= rhs.0;
17983    }
17984}
17985impl core::ops::BitAnd for RenderPassCreateFlagBits {
17986    type Output = Self;
17987    #[inline]
17988    fn bitand(self, rhs: Self) -> Self {
17989        Self(self.0 & rhs.0)
17990    }
17991}
17992impl core::ops::BitAndAssign for RenderPassCreateFlagBits {
17993    #[inline]
17994    fn bitand_assign(&mut self, rhs: Self) {
17995        self.0 &= rhs.0;
17996    }
17997}
17998impl core::ops::BitXor for RenderPassCreateFlagBits {
17999    type Output = Self;
18000    #[inline]
18001    fn bitxor(self, rhs: Self) -> Self {
18002        Self(self.0 ^ rhs.0)
18003    }
18004}
18005impl core::ops::BitXorAssign for RenderPassCreateFlagBits {
18006    #[inline]
18007    fn bitxor_assign(&mut self, rhs: Self) {
18008        self.0 ^= rhs.0;
18009    }
18010}
18011impl core::ops::Not for RenderPassCreateFlagBits {
18012    type Output = Self;
18013    #[inline]
18014    fn not(self) -> Self {
18015        Self(!self.0)
18016    }
18017}
18018impl core::fmt::Debug for RenderPassCreateFlagBits {
18019    #[allow(unused_mut, unused_variables)]
18020    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18021        let mut first = true;
18022        let mut remaining = self.0;
18023        if remaining & Self::TRANSFORM_BIT.0 != 0 {
18024            if !first {
18025                f.write_str(" | ")?;
18026            }
18027            f.write_str("TRANSFORM_BIT")?;
18028            remaining &= !Self::TRANSFORM_BIT.0;
18029            first = false;
18030        }
18031        if remaining & Self::PER_LAYER_FRAGMENT_DENSITY_BIT.0 != 0 {
18032            if !first {
18033                f.write_str(" | ")?;
18034            }
18035            f.write_str("PER_LAYER_FRAGMENT_DENSITY_BIT")?;
18036            remaining &= !Self::PER_LAYER_FRAGMENT_DENSITY_BIT.0;
18037            first = false;
18038        }
18039        if remaining != 0u32 {
18040            if !first {
18041                f.write_str(" | ")?;
18042            }
18043            write!(f, "{:#x}", remaining)?;
18044        } else if first {
18045            f.write_str("(empty)")?;
18046        }
18047        Ok(())
18048    }
18049}
18050///[`VkRenderingAttachmentFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentFlagBitsKHR.html)
18051#[repr(transparent)]
18052#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
18053#[doc(alias = "VkRenderingAttachmentFlagBitsKHR")]
18054pub struct RenderingAttachmentFlagBitsKHR(u32);
18055impl RenderingAttachmentFlagBitsKHR {
18056    #[inline]
18057    pub const fn empty() -> Self {
18058        Self(0u32)
18059    }
18060    #[inline]
18061    pub const fn from_raw(value: u32) -> Self {
18062        Self(value)
18063    }
18064    #[inline]
18065    pub const fn as_raw(self) -> u32 {
18066        self.0
18067    }
18068    #[inline]
18069    pub const fn is_empty(self) -> bool {
18070        self.0 == 0u32
18071    }
18072    #[inline]
18073    pub const fn contains(self, other: Self) -> bool {
18074        (self.0 & other.0) == other.0
18075    }
18076    #[inline]
18077    pub const fn all() -> Self {
18078        Self(7u32)
18079    }
18080    ///Bit 0.
18081    pub const INPUT_ATTACHMENT_FEEDBACK: Self = Self(1u32);
18082    ///Bit 1.
18083    pub const RESOLVE_SKIP_TRANSFER_FUNCTION: Self = Self(2u32);
18084    ///Bit 2.
18085    pub const RESOLVE_ENABLE_TRANSFER_FUNCTION: Self = Self(4u32);
18086}
18087impl core::ops::BitOr for RenderingAttachmentFlagBitsKHR {
18088    type Output = Self;
18089    #[inline]
18090    fn bitor(self, rhs: Self) -> Self {
18091        Self(self.0 | rhs.0)
18092    }
18093}
18094impl core::ops::BitOrAssign for RenderingAttachmentFlagBitsKHR {
18095    #[inline]
18096    fn bitor_assign(&mut self, rhs: Self) {
18097        self.0 |= rhs.0;
18098    }
18099}
18100impl core::ops::BitAnd for RenderingAttachmentFlagBitsKHR {
18101    type Output = Self;
18102    #[inline]
18103    fn bitand(self, rhs: Self) -> Self {
18104        Self(self.0 & rhs.0)
18105    }
18106}
18107impl core::ops::BitAndAssign for RenderingAttachmentFlagBitsKHR {
18108    #[inline]
18109    fn bitand_assign(&mut self, rhs: Self) {
18110        self.0 &= rhs.0;
18111    }
18112}
18113impl core::ops::BitXor for RenderingAttachmentFlagBitsKHR {
18114    type Output = Self;
18115    #[inline]
18116    fn bitxor(self, rhs: Self) -> Self {
18117        Self(self.0 ^ rhs.0)
18118    }
18119}
18120impl core::ops::BitXorAssign for RenderingAttachmentFlagBitsKHR {
18121    #[inline]
18122    fn bitxor_assign(&mut self, rhs: Self) {
18123        self.0 ^= rhs.0;
18124    }
18125}
18126impl core::ops::Not for RenderingAttachmentFlagBitsKHR {
18127    type Output = Self;
18128    #[inline]
18129    fn not(self) -> Self {
18130        Self(!self.0)
18131    }
18132}
18133impl core::fmt::Debug for RenderingAttachmentFlagBitsKHR {
18134    #[allow(unused_mut, unused_variables)]
18135    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18136        let mut first = true;
18137        let mut remaining = self.0;
18138        if remaining & Self::INPUT_ATTACHMENT_FEEDBACK.0 != 0 {
18139            if !first {
18140                f.write_str(" | ")?;
18141            }
18142            f.write_str("INPUT_ATTACHMENT_FEEDBACK")?;
18143            remaining &= !Self::INPUT_ATTACHMENT_FEEDBACK.0;
18144            first = false;
18145        }
18146        if remaining & Self::RESOLVE_SKIP_TRANSFER_FUNCTION.0 != 0 {
18147            if !first {
18148                f.write_str(" | ")?;
18149            }
18150            f.write_str("RESOLVE_SKIP_TRANSFER_FUNCTION")?;
18151            remaining &= !Self::RESOLVE_SKIP_TRANSFER_FUNCTION.0;
18152            first = false;
18153        }
18154        if remaining & Self::RESOLVE_ENABLE_TRANSFER_FUNCTION.0 != 0 {
18155            if !first {
18156                f.write_str(" | ")?;
18157            }
18158            f.write_str("RESOLVE_ENABLE_TRANSFER_FUNCTION")?;
18159            remaining &= !Self::RESOLVE_ENABLE_TRANSFER_FUNCTION.0;
18160            first = false;
18161        }
18162        if remaining != 0u32 {
18163            if !first {
18164                f.write_str(" | ")?;
18165            }
18166            write!(f, "{:#x}", remaining)?;
18167        } else if first {
18168            f.write_str("(empty)")?;
18169        }
18170        Ok(())
18171    }
18172}
18173///[`VkRenderingFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFlagBits.html)
18174#[repr(transparent)]
18175#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
18176#[doc(alias = "VkRenderingFlagBits")]
18177pub struct RenderingFlagBits(u32);
18178impl RenderingFlagBits {
18179    #[inline]
18180    pub const fn empty() -> Self {
18181        Self(0u32)
18182    }
18183    #[inline]
18184    pub const fn from_raw(value: u32) -> Self {
18185        Self(value)
18186    }
18187    #[inline]
18188    pub const fn as_raw(self) -> u32 {
18189        self.0
18190    }
18191    #[inline]
18192    pub const fn is_empty(self) -> bool {
18193        self.0 == 0u32
18194    }
18195    #[inline]
18196    pub const fn contains(self, other: Self) -> bool {
18197        (self.0 & other.0) == other.0
18198    }
18199    #[inline]
18200    pub const fn all() -> Self {
18201        Self(495u32)
18202    }
18203    ///Bit 0.
18204    pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(1u32);
18205    ///Bit 1.
18206    pub const SUSPENDING: Self = Self(2u32);
18207    ///Bit 2.
18208    pub const RESUMING: Self = Self(4u32);
18209    ///Bit 3.
18210    pub const ENABLE_LEGACY_DITHERING: Self = Self(8u32);
18211    ///Bit 5.
18212    pub const PER_LAYER_FRAGMENT_DENSITY_BIT: Self = Self(32u32);
18213    ///Bit 6.
18214    pub const FRAGMENT_REGION: Self = Self(64u32);
18215    ///Bit 7.
18216    pub const CUSTOM_RESOLVE: Self = Self(128u32);
18217    ///Bit 8.
18218    pub const LOCAL_READ_CONCURRENT_ACCESS_CONTROL: Self = Self(256u32);
18219}
18220impl core::ops::BitOr for RenderingFlagBits {
18221    type Output = Self;
18222    #[inline]
18223    fn bitor(self, rhs: Self) -> Self {
18224        Self(self.0 | rhs.0)
18225    }
18226}
18227impl core::ops::BitOrAssign for RenderingFlagBits {
18228    #[inline]
18229    fn bitor_assign(&mut self, rhs: Self) {
18230        self.0 |= rhs.0;
18231    }
18232}
18233impl core::ops::BitAnd for RenderingFlagBits {
18234    type Output = Self;
18235    #[inline]
18236    fn bitand(self, rhs: Self) -> Self {
18237        Self(self.0 & rhs.0)
18238    }
18239}
18240impl core::ops::BitAndAssign for RenderingFlagBits {
18241    #[inline]
18242    fn bitand_assign(&mut self, rhs: Self) {
18243        self.0 &= rhs.0;
18244    }
18245}
18246impl core::ops::BitXor for RenderingFlagBits {
18247    type Output = Self;
18248    #[inline]
18249    fn bitxor(self, rhs: Self) -> Self {
18250        Self(self.0 ^ rhs.0)
18251    }
18252}
18253impl core::ops::BitXorAssign for RenderingFlagBits {
18254    #[inline]
18255    fn bitxor_assign(&mut self, rhs: Self) {
18256        self.0 ^= rhs.0;
18257    }
18258}
18259impl core::ops::Not for RenderingFlagBits {
18260    type Output = Self;
18261    #[inline]
18262    fn not(self) -> Self {
18263        Self(!self.0)
18264    }
18265}
18266impl core::fmt::Debug for RenderingFlagBits {
18267    #[allow(unused_mut, unused_variables)]
18268    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18269        let mut first = true;
18270        let mut remaining = self.0;
18271        if remaining & Self::CONTENTS_SECONDARY_COMMAND_BUFFERS.0 != 0 {
18272            if !first {
18273                f.write_str(" | ")?;
18274            }
18275            f.write_str("CONTENTS_SECONDARY_COMMAND_BUFFERS")?;
18276            remaining &= !Self::CONTENTS_SECONDARY_COMMAND_BUFFERS.0;
18277            first = false;
18278        }
18279        if remaining & Self::SUSPENDING.0 != 0 {
18280            if !first {
18281                f.write_str(" | ")?;
18282            }
18283            f.write_str("SUSPENDING")?;
18284            remaining &= !Self::SUSPENDING.0;
18285            first = false;
18286        }
18287        if remaining & Self::RESUMING.0 != 0 {
18288            if !first {
18289                f.write_str(" | ")?;
18290            }
18291            f.write_str("RESUMING")?;
18292            remaining &= !Self::RESUMING.0;
18293            first = false;
18294        }
18295        if remaining & Self::ENABLE_LEGACY_DITHERING.0 != 0 {
18296            if !first {
18297                f.write_str(" | ")?;
18298            }
18299            f.write_str("ENABLE_LEGACY_DITHERING")?;
18300            remaining &= !Self::ENABLE_LEGACY_DITHERING.0;
18301            first = false;
18302        }
18303        if remaining & Self::PER_LAYER_FRAGMENT_DENSITY_BIT.0 != 0 {
18304            if !first {
18305                f.write_str(" | ")?;
18306            }
18307            f.write_str("PER_LAYER_FRAGMENT_DENSITY_BIT")?;
18308            remaining &= !Self::PER_LAYER_FRAGMENT_DENSITY_BIT.0;
18309            first = false;
18310        }
18311        if remaining & Self::FRAGMENT_REGION.0 != 0 {
18312            if !first {
18313                f.write_str(" | ")?;
18314            }
18315            f.write_str("FRAGMENT_REGION")?;
18316            remaining &= !Self::FRAGMENT_REGION.0;
18317            first = false;
18318        }
18319        if remaining & Self::CUSTOM_RESOLVE.0 != 0 {
18320            if !first {
18321                f.write_str(" | ")?;
18322            }
18323            f.write_str("CUSTOM_RESOLVE")?;
18324            remaining &= !Self::CUSTOM_RESOLVE.0;
18325            first = false;
18326        }
18327        if remaining & Self::LOCAL_READ_CONCURRENT_ACCESS_CONTROL.0 != 0 {
18328            if !first {
18329                f.write_str(" | ")?;
18330            }
18331            f.write_str("LOCAL_READ_CONCURRENT_ACCESS_CONTROL")?;
18332            remaining &= !Self::LOCAL_READ_CONCURRENT_ACCESS_CONTROL.0;
18333            first = false;
18334        }
18335        if remaining != 0u32 {
18336            if !first {
18337                f.write_str(" | ")?;
18338            }
18339            write!(f, "{:#x}", remaining)?;
18340        } else if first {
18341            f.write_str("(empty)")?;
18342        }
18343        Ok(())
18344    }
18345}
18346///[`VkResolveImageFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageFlagBitsKHR.html)
18347#[repr(transparent)]
18348#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
18349#[doc(alias = "VkResolveImageFlagBitsKHR")]
18350pub struct ResolveImageFlagBitsKHR(u32);
18351impl ResolveImageFlagBitsKHR {
18352    #[inline]
18353    pub const fn empty() -> Self {
18354        Self(0u32)
18355    }
18356    #[inline]
18357    pub const fn from_raw(value: u32) -> Self {
18358        Self(value)
18359    }
18360    #[inline]
18361    pub const fn as_raw(self) -> u32 {
18362        self.0
18363    }
18364    #[inline]
18365    pub const fn is_empty(self) -> bool {
18366        self.0 == 0u32
18367    }
18368    #[inline]
18369    pub const fn contains(self, other: Self) -> bool {
18370        (self.0 & other.0) == other.0
18371    }
18372    #[inline]
18373    pub const fn all() -> Self {
18374        Self(3u32)
18375    }
18376    ///Bit 0.
18377    pub const SKIP_TRANSFER_FUNCTION: Self = Self(1u32);
18378    ///Bit 1.
18379    pub const ENABLE_TRANSFER_FUNCTION: Self = Self(2u32);
18380}
18381impl core::ops::BitOr for ResolveImageFlagBitsKHR {
18382    type Output = Self;
18383    #[inline]
18384    fn bitor(self, rhs: Self) -> Self {
18385        Self(self.0 | rhs.0)
18386    }
18387}
18388impl core::ops::BitOrAssign for ResolveImageFlagBitsKHR {
18389    #[inline]
18390    fn bitor_assign(&mut self, rhs: Self) {
18391        self.0 |= rhs.0;
18392    }
18393}
18394impl core::ops::BitAnd for ResolveImageFlagBitsKHR {
18395    type Output = Self;
18396    #[inline]
18397    fn bitand(self, rhs: Self) -> Self {
18398        Self(self.0 & rhs.0)
18399    }
18400}
18401impl core::ops::BitAndAssign for ResolveImageFlagBitsKHR {
18402    #[inline]
18403    fn bitand_assign(&mut self, rhs: Self) {
18404        self.0 &= rhs.0;
18405    }
18406}
18407impl core::ops::BitXor for ResolveImageFlagBitsKHR {
18408    type Output = Self;
18409    #[inline]
18410    fn bitxor(self, rhs: Self) -> Self {
18411        Self(self.0 ^ rhs.0)
18412    }
18413}
18414impl core::ops::BitXorAssign for ResolveImageFlagBitsKHR {
18415    #[inline]
18416    fn bitxor_assign(&mut self, rhs: Self) {
18417        self.0 ^= rhs.0;
18418    }
18419}
18420impl core::ops::Not for ResolveImageFlagBitsKHR {
18421    type Output = Self;
18422    #[inline]
18423    fn not(self) -> Self {
18424        Self(!self.0)
18425    }
18426}
18427impl core::fmt::Debug for ResolveImageFlagBitsKHR {
18428    #[allow(unused_mut, unused_variables)]
18429    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18430        let mut first = true;
18431        let mut remaining = self.0;
18432        if remaining & Self::SKIP_TRANSFER_FUNCTION.0 != 0 {
18433            if !first {
18434                f.write_str(" | ")?;
18435            }
18436            f.write_str("SKIP_TRANSFER_FUNCTION")?;
18437            remaining &= !Self::SKIP_TRANSFER_FUNCTION.0;
18438            first = false;
18439        }
18440        if remaining & Self::ENABLE_TRANSFER_FUNCTION.0 != 0 {
18441            if !first {
18442                f.write_str(" | ")?;
18443            }
18444            f.write_str("ENABLE_TRANSFER_FUNCTION")?;
18445            remaining &= !Self::ENABLE_TRANSFER_FUNCTION.0;
18446            first = false;
18447        }
18448        if remaining != 0u32 {
18449            if !first {
18450                f.write_str(" | ")?;
18451            }
18452            write!(f, "{:#x}", remaining)?;
18453        } else if first {
18454            f.write_str("(empty)")?;
18455        }
18456        Ok(())
18457    }
18458}
18459///[`VkResolveModeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveModeFlagBits.html)
18460#[repr(transparent)]
18461#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
18462#[doc(alias = "VkResolveModeFlagBits")]
18463pub struct ResolveModeFlagBits(u32);
18464impl ResolveModeFlagBits {
18465    #[inline]
18466    pub const fn empty() -> Self {
18467        Self(0u32)
18468    }
18469    #[inline]
18470    pub const fn from_raw(value: u32) -> Self {
18471        Self(value)
18472    }
18473    #[inline]
18474    pub const fn as_raw(self) -> u32 {
18475        self.0
18476    }
18477    #[inline]
18478    pub const fn is_empty(self) -> bool {
18479        self.0 == 0u32
18480    }
18481    #[inline]
18482    pub const fn contains(self, other: Self) -> bool {
18483        (self.0 & other.0) == other.0
18484    }
18485    #[inline]
18486    pub const fn all() -> Self {
18487        Self(63u32)
18488    }
18489    pub const NONE: Self = Self(0u32);
18490    ///Bit 0.
18491    pub const SAMPLE_ZERO: Self = Self(1u32);
18492    ///Bit 1.
18493    pub const AVERAGE: Self = Self(2u32);
18494    ///Bit 2.
18495    pub const MIN: Self = Self(4u32);
18496    ///Bit 3.
18497    pub const MAX: Self = Self(8u32);
18498    ///Bit 4.
18499    pub const EXTERNAL_FORMAT_DOWNSAMPLE_BIT: Self = Self(16u32);
18500    pub const EXTERNAL_FORMAT_DOWNSAMPLE: Self = Self::EXTERNAL_FORMAT_DOWNSAMPLE_BIT;
18501    ///Bit 5.
18502    pub const CUSTOM: Self = Self(32u32);
18503}
18504impl core::ops::BitOr for ResolveModeFlagBits {
18505    type Output = Self;
18506    #[inline]
18507    fn bitor(self, rhs: Self) -> Self {
18508        Self(self.0 | rhs.0)
18509    }
18510}
18511impl core::ops::BitOrAssign for ResolveModeFlagBits {
18512    #[inline]
18513    fn bitor_assign(&mut self, rhs: Self) {
18514        self.0 |= rhs.0;
18515    }
18516}
18517impl core::ops::BitAnd for ResolveModeFlagBits {
18518    type Output = Self;
18519    #[inline]
18520    fn bitand(self, rhs: Self) -> Self {
18521        Self(self.0 & rhs.0)
18522    }
18523}
18524impl core::ops::BitAndAssign for ResolveModeFlagBits {
18525    #[inline]
18526    fn bitand_assign(&mut self, rhs: Self) {
18527        self.0 &= rhs.0;
18528    }
18529}
18530impl core::ops::BitXor for ResolveModeFlagBits {
18531    type Output = Self;
18532    #[inline]
18533    fn bitxor(self, rhs: Self) -> Self {
18534        Self(self.0 ^ rhs.0)
18535    }
18536}
18537impl core::ops::BitXorAssign for ResolveModeFlagBits {
18538    #[inline]
18539    fn bitxor_assign(&mut self, rhs: Self) {
18540        self.0 ^= rhs.0;
18541    }
18542}
18543impl core::ops::Not for ResolveModeFlagBits {
18544    type Output = Self;
18545    #[inline]
18546    fn not(self) -> Self {
18547        Self(!self.0)
18548    }
18549}
18550impl core::fmt::Debug for ResolveModeFlagBits {
18551    #[allow(unused_mut, unused_variables)]
18552    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18553        let mut first = true;
18554        let mut remaining = self.0;
18555        if remaining & Self::SAMPLE_ZERO.0 != 0 {
18556            if !first {
18557                f.write_str(" | ")?;
18558            }
18559            f.write_str("SAMPLE_ZERO")?;
18560            remaining &= !Self::SAMPLE_ZERO.0;
18561            first = false;
18562        }
18563        if remaining & Self::AVERAGE.0 != 0 {
18564            if !first {
18565                f.write_str(" | ")?;
18566            }
18567            f.write_str("AVERAGE")?;
18568            remaining &= !Self::AVERAGE.0;
18569            first = false;
18570        }
18571        if remaining & Self::MIN.0 != 0 {
18572            if !first {
18573                f.write_str(" | ")?;
18574            }
18575            f.write_str("MIN")?;
18576            remaining &= !Self::MIN.0;
18577            first = false;
18578        }
18579        if remaining & Self::MAX.0 != 0 {
18580            if !first {
18581                f.write_str(" | ")?;
18582            }
18583            f.write_str("MAX")?;
18584            remaining &= !Self::MAX.0;
18585            first = false;
18586        }
18587        if remaining & Self::EXTERNAL_FORMAT_DOWNSAMPLE_BIT.0 != 0 {
18588            if !first {
18589                f.write_str(" | ")?;
18590            }
18591            f.write_str("EXTERNAL_FORMAT_DOWNSAMPLE_BIT")?;
18592            remaining &= !Self::EXTERNAL_FORMAT_DOWNSAMPLE_BIT.0;
18593            first = false;
18594        }
18595        if remaining & Self::CUSTOM.0 != 0 {
18596            if !first {
18597                f.write_str(" | ")?;
18598            }
18599            f.write_str("CUSTOM")?;
18600            remaining &= !Self::CUSTOM.0;
18601            first = false;
18602        }
18603        if remaining != 0u32 {
18604            if !first {
18605                f.write_str(" | ")?;
18606            }
18607            write!(f, "{:#x}", remaining)?;
18608        } else if first {
18609            f.write_str("(empty)")?;
18610        }
18611        Ok(())
18612    }
18613}
18614///[`VkSampleCountFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleCountFlagBits.html)
18615#[repr(transparent)]
18616#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
18617#[doc(alias = "VkSampleCountFlagBits")]
18618pub struct SampleCountFlagBits(u32);
18619impl SampleCountFlagBits {
18620    #[inline]
18621    pub const fn empty() -> Self {
18622        Self(0u32)
18623    }
18624    #[inline]
18625    pub const fn from_raw(value: u32) -> Self {
18626        Self(value)
18627    }
18628    #[inline]
18629    pub const fn as_raw(self) -> u32 {
18630        self.0
18631    }
18632    #[inline]
18633    pub const fn is_empty(self) -> bool {
18634        self.0 == 0u32
18635    }
18636    #[inline]
18637    pub const fn contains(self, other: Self) -> bool {
18638        (self.0 & other.0) == other.0
18639    }
18640    #[inline]
18641    pub const fn all() -> Self {
18642        Self(127u32)
18643    }
18644    ///Bit 0.
18645    pub const _1: Self = Self(1u32);
18646    ///Bit 1.
18647    pub const _2: Self = Self(2u32);
18648    ///Bit 2.
18649    pub const _4: Self = Self(4u32);
18650    ///Bit 3.
18651    pub const _8: Self = Self(8u32);
18652    ///Bit 4.
18653    pub const _16: Self = Self(16u32);
18654    ///Bit 5.
18655    pub const _32: Self = Self(32u32);
18656    ///Bit 6.
18657    pub const _64: Self = Self(64u32);
18658}
18659impl core::ops::BitOr for SampleCountFlagBits {
18660    type Output = Self;
18661    #[inline]
18662    fn bitor(self, rhs: Self) -> Self {
18663        Self(self.0 | rhs.0)
18664    }
18665}
18666impl core::ops::BitOrAssign for SampleCountFlagBits {
18667    #[inline]
18668    fn bitor_assign(&mut self, rhs: Self) {
18669        self.0 |= rhs.0;
18670    }
18671}
18672impl core::ops::BitAnd for SampleCountFlagBits {
18673    type Output = Self;
18674    #[inline]
18675    fn bitand(self, rhs: Self) -> Self {
18676        Self(self.0 & rhs.0)
18677    }
18678}
18679impl core::ops::BitAndAssign for SampleCountFlagBits {
18680    #[inline]
18681    fn bitand_assign(&mut self, rhs: Self) {
18682        self.0 &= rhs.0;
18683    }
18684}
18685impl core::ops::BitXor for SampleCountFlagBits {
18686    type Output = Self;
18687    #[inline]
18688    fn bitxor(self, rhs: Self) -> Self {
18689        Self(self.0 ^ rhs.0)
18690    }
18691}
18692impl core::ops::BitXorAssign for SampleCountFlagBits {
18693    #[inline]
18694    fn bitxor_assign(&mut self, rhs: Self) {
18695        self.0 ^= rhs.0;
18696    }
18697}
18698impl core::ops::Not for SampleCountFlagBits {
18699    type Output = Self;
18700    #[inline]
18701    fn not(self) -> Self {
18702        Self(!self.0)
18703    }
18704}
18705impl core::fmt::Debug for SampleCountFlagBits {
18706    #[allow(unused_mut, unused_variables)]
18707    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18708        let mut first = true;
18709        let mut remaining = self.0;
18710        if remaining & Self::_1.0 != 0 {
18711            if !first {
18712                f.write_str(" | ")?;
18713            }
18714            f.write_str("_1")?;
18715            remaining &= !Self::_1.0;
18716            first = false;
18717        }
18718        if remaining & Self::_2.0 != 0 {
18719            if !first {
18720                f.write_str(" | ")?;
18721            }
18722            f.write_str("_2")?;
18723            remaining &= !Self::_2.0;
18724            first = false;
18725        }
18726        if remaining & Self::_4.0 != 0 {
18727            if !first {
18728                f.write_str(" | ")?;
18729            }
18730            f.write_str("_4")?;
18731            remaining &= !Self::_4.0;
18732            first = false;
18733        }
18734        if remaining & Self::_8.0 != 0 {
18735            if !first {
18736                f.write_str(" | ")?;
18737            }
18738            f.write_str("_8")?;
18739            remaining &= !Self::_8.0;
18740            first = false;
18741        }
18742        if remaining & Self::_16.0 != 0 {
18743            if !first {
18744                f.write_str(" | ")?;
18745            }
18746            f.write_str("_16")?;
18747            remaining &= !Self::_16.0;
18748            first = false;
18749        }
18750        if remaining & Self::_32.0 != 0 {
18751            if !first {
18752                f.write_str(" | ")?;
18753            }
18754            f.write_str("_32")?;
18755            remaining &= !Self::_32.0;
18756            first = false;
18757        }
18758        if remaining & Self::_64.0 != 0 {
18759            if !first {
18760                f.write_str(" | ")?;
18761            }
18762            f.write_str("_64")?;
18763            remaining &= !Self::_64.0;
18764            first = false;
18765        }
18766        if remaining != 0u32 {
18767            if !first {
18768                f.write_str(" | ")?;
18769            }
18770            write!(f, "{:#x}", remaining)?;
18771        } else if first {
18772            f.write_str("(empty)")?;
18773        }
18774        Ok(())
18775    }
18776}
18777///[`VkSamplerCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateFlagBits.html)
18778#[repr(transparent)]
18779#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
18780#[doc(alias = "VkSamplerCreateFlagBits")]
18781pub struct SamplerCreateFlagBits(u32);
18782impl SamplerCreateFlagBits {
18783    #[inline]
18784    pub const fn empty() -> Self {
18785        Self(0u32)
18786    }
18787    #[inline]
18788    pub const fn from_raw(value: u32) -> Self {
18789        Self(value)
18790    }
18791    #[inline]
18792    pub const fn as_raw(self) -> u32 {
18793        self.0
18794    }
18795    #[inline]
18796    pub const fn is_empty(self) -> bool {
18797        self.0 == 0u32
18798    }
18799    #[inline]
18800    pub const fn contains(self, other: Self) -> bool {
18801        (self.0 & other.0) == other.0
18802    }
18803    #[inline]
18804    pub const fn all() -> Self {
18805        Self(31u32)
18806    }
18807    ///Bit 0.
18808    pub const SUBSAMPLED: Self = Self(1u32);
18809    ///Bit 1.
18810    pub const SUBSAMPLED_COARSE_RECONSTRUCTION: Self = Self(2u32);
18811    ///Bit 3.
18812    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self(8u32);
18813    ///Bit 2.
18814    pub const NON_SEAMLESS_CUBE_MAP: Self = Self(4u32);
18815    ///Bit 4.
18816    pub const IMAGE_PROCESSING_BIT: Self = Self(16u32);
18817}
18818impl core::ops::BitOr for SamplerCreateFlagBits {
18819    type Output = Self;
18820    #[inline]
18821    fn bitor(self, rhs: Self) -> Self {
18822        Self(self.0 | rhs.0)
18823    }
18824}
18825impl core::ops::BitOrAssign for SamplerCreateFlagBits {
18826    #[inline]
18827    fn bitor_assign(&mut self, rhs: Self) {
18828        self.0 |= rhs.0;
18829    }
18830}
18831impl core::ops::BitAnd for SamplerCreateFlagBits {
18832    type Output = Self;
18833    #[inline]
18834    fn bitand(self, rhs: Self) -> Self {
18835        Self(self.0 & rhs.0)
18836    }
18837}
18838impl core::ops::BitAndAssign for SamplerCreateFlagBits {
18839    #[inline]
18840    fn bitand_assign(&mut self, rhs: Self) {
18841        self.0 &= rhs.0;
18842    }
18843}
18844impl core::ops::BitXor for SamplerCreateFlagBits {
18845    type Output = Self;
18846    #[inline]
18847    fn bitxor(self, rhs: Self) -> Self {
18848        Self(self.0 ^ rhs.0)
18849    }
18850}
18851impl core::ops::BitXorAssign for SamplerCreateFlagBits {
18852    #[inline]
18853    fn bitxor_assign(&mut self, rhs: Self) {
18854        self.0 ^= rhs.0;
18855    }
18856}
18857impl core::ops::Not for SamplerCreateFlagBits {
18858    type Output = Self;
18859    #[inline]
18860    fn not(self) -> Self {
18861        Self(!self.0)
18862    }
18863}
18864impl core::fmt::Debug for SamplerCreateFlagBits {
18865    #[allow(unused_mut, unused_variables)]
18866    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18867        let mut first = true;
18868        let mut remaining = self.0;
18869        if remaining & Self::SUBSAMPLED.0 != 0 {
18870            if !first {
18871                f.write_str(" | ")?;
18872            }
18873            f.write_str("SUBSAMPLED")?;
18874            remaining &= !Self::SUBSAMPLED.0;
18875            first = false;
18876        }
18877        if remaining & Self::SUBSAMPLED_COARSE_RECONSTRUCTION.0 != 0 {
18878            if !first {
18879                f.write_str(" | ")?;
18880            }
18881            f.write_str("SUBSAMPLED_COARSE_RECONSTRUCTION")?;
18882            remaining &= !Self::SUBSAMPLED_COARSE_RECONSTRUCTION.0;
18883            first = false;
18884        }
18885        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0 != 0 {
18886            if !first {
18887                f.write_str(" | ")?;
18888            }
18889            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY")?;
18890            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0;
18891            first = false;
18892        }
18893        if remaining & Self::NON_SEAMLESS_CUBE_MAP.0 != 0 {
18894            if !first {
18895                f.write_str(" | ")?;
18896            }
18897            f.write_str("NON_SEAMLESS_CUBE_MAP")?;
18898            remaining &= !Self::NON_SEAMLESS_CUBE_MAP.0;
18899            first = false;
18900        }
18901        if remaining & Self::IMAGE_PROCESSING_BIT.0 != 0 {
18902            if !first {
18903                f.write_str(" | ")?;
18904            }
18905            f.write_str("IMAGE_PROCESSING_BIT")?;
18906            remaining &= !Self::IMAGE_PROCESSING_BIT.0;
18907            first = false;
18908        }
18909        if remaining != 0u32 {
18910            if !first {
18911                f.write_str(" | ")?;
18912            }
18913            write!(f, "{:#x}", remaining)?;
18914        } else if first {
18915            f.write_str("(empty)")?;
18916        }
18917        Ok(())
18918    }
18919}
18920///[`VkSemaphoreCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreCreateFlagBits.html)
18921#[repr(transparent)]
18922#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
18923#[doc(alias = "VkSemaphoreCreateFlagBits")]
18924pub struct SemaphoreCreateFlagBits(u32);
18925impl SemaphoreCreateFlagBits {
18926    #[inline]
18927    pub const fn empty() -> Self {
18928        Self(0u32)
18929    }
18930    #[inline]
18931    pub const fn from_raw(value: u32) -> Self {
18932        Self(value)
18933    }
18934    #[inline]
18935    pub const fn as_raw(self) -> u32 {
18936        self.0
18937    }
18938    #[inline]
18939    pub const fn is_empty(self) -> bool {
18940        self.0 == 0u32
18941    }
18942    #[inline]
18943    pub const fn contains(self, other: Self) -> bool {
18944        (self.0 & other.0) == other.0
18945    }
18946    #[inline]
18947    pub const fn all() -> Self {
18948        Self(0u32)
18949    }
18950}
18951impl core::ops::BitOr for SemaphoreCreateFlagBits {
18952    type Output = Self;
18953    #[inline]
18954    fn bitor(self, rhs: Self) -> Self {
18955        Self(self.0 | rhs.0)
18956    }
18957}
18958impl core::ops::BitOrAssign for SemaphoreCreateFlagBits {
18959    #[inline]
18960    fn bitor_assign(&mut self, rhs: Self) {
18961        self.0 |= rhs.0;
18962    }
18963}
18964impl core::ops::BitAnd for SemaphoreCreateFlagBits {
18965    type Output = Self;
18966    #[inline]
18967    fn bitand(self, rhs: Self) -> Self {
18968        Self(self.0 & rhs.0)
18969    }
18970}
18971impl core::ops::BitAndAssign for SemaphoreCreateFlagBits {
18972    #[inline]
18973    fn bitand_assign(&mut self, rhs: Self) {
18974        self.0 &= rhs.0;
18975    }
18976}
18977impl core::ops::BitXor for SemaphoreCreateFlagBits {
18978    type Output = Self;
18979    #[inline]
18980    fn bitxor(self, rhs: Self) -> Self {
18981        Self(self.0 ^ rhs.0)
18982    }
18983}
18984impl core::ops::BitXorAssign for SemaphoreCreateFlagBits {
18985    #[inline]
18986    fn bitxor_assign(&mut self, rhs: Self) {
18987        self.0 ^= rhs.0;
18988    }
18989}
18990impl core::ops::Not for SemaphoreCreateFlagBits {
18991    type Output = Self;
18992    #[inline]
18993    fn not(self) -> Self {
18994        Self(!self.0)
18995    }
18996}
18997impl core::fmt::Debug for SemaphoreCreateFlagBits {
18998    #[allow(unused_mut, unused_variables)]
18999    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19000        let mut first = true;
19001        let mut remaining = self.0;
19002        if remaining != 0u32 {
19003            if !first {
19004                f.write_str(" | ")?;
19005            }
19006            write!(f, "{:#x}", remaining)?;
19007        } else if first {
19008            f.write_str("(empty)")?;
19009        }
19010        Ok(())
19011    }
19012}
19013///[`VkSemaphoreImportFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreImportFlagBits.html)
19014#[repr(transparent)]
19015#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19016#[doc(alias = "VkSemaphoreImportFlagBits")]
19017pub struct SemaphoreImportFlagBits(u32);
19018impl SemaphoreImportFlagBits {
19019    #[inline]
19020    pub const fn empty() -> Self {
19021        Self(0u32)
19022    }
19023    #[inline]
19024    pub const fn from_raw(value: u32) -> Self {
19025        Self(value)
19026    }
19027    #[inline]
19028    pub const fn as_raw(self) -> u32 {
19029        self.0
19030    }
19031    #[inline]
19032    pub const fn is_empty(self) -> bool {
19033        self.0 == 0u32
19034    }
19035    #[inline]
19036    pub const fn contains(self, other: Self) -> bool {
19037        (self.0 & other.0) == other.0
19038    }
19039    #[inline]
19040    pub const fn all() -> Self {
19041        Self(1u32)
19042    }
19043    ///Bit 0.
19044    pub const TEMPORARY: Self = Self(1u32);
19045}
19046impl core::ops::BitOr for SemaphoreImportFlagBits {
19047    type Output = Self;
19048    #[inline]
19049    fn bitor(self, rhs: Self) -> Self {
19050        Self(self.0 | rhs.0)
19051    }
19052}
19053impl core::ops::BitOrAssign for SemaphoreImportFlagBits {
19054    #[inline]
19055    fn bitor_assign(&mut self, rhs: Self) {
19056        self.0 |= rhs.0;
19057    }
19058}
19059impl core::ops::BitAnd for SemaphoreImportFlagBits {
19060    type Output = Self;
19061    #[inline]
19062    fn bitand(self, rhs: Self) -> Self {
19063        Self(self.0 & rhs.0)
19064    }
19065}
19066impl core::ops::BitAndAssign for SemaphoreImportFlagBits {
19067    #[inline]
19068    fn bitand_assign(&mut self, rhs: Self) {
19069        self.0 &= rhs.0;
19070    }
19071}
19072impl core::ops::BitXor for SemaphoreImportFlagBits {
19073    type Output = Self;
19074    #[inline]
19075    fn bitxor(self, rhs: Self) -> Self {
19076        Self(self.0 ^ rhs.0)
19077    }
19078}
19079impl core::ops::BitXorAssign for SemaphoreImportFlagBits {
19080    #[inline]
19081    fn bitxor_assign(&mut self, rhs: Self) {
19082        self.0 ^= rhs.0;
19083    }
19084}
19085impl core::ops::Not for SemaphoreImportFlagBits {
19086    type Output = Self;
19087    #[inline]
19088    fn not(self) -> Self {
19089        Self(!self.0)
19090    }
19091}
19092impl core::fmt::Debug for SemaphoreImportFlagBits {
19093    #[allow(unused_mut, unused_variables)]
19094    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19095        let mut first = true;
19096        let mut remaining = self.0;
19097        if remaining & Self::TEMPORARY.0 != 0 {
19098            if !first {
19099                f.write_str(" | ")?;
19100            }
19101            f.write_str("TEMPORARY")?;
19102            remaining &= !Self::TEMPORARY.0;
19103            first = false;
19104        }
19105        if remaining != 0u32 {
19106            if !first {
19107                f.write_str(" | ")?;
19108            }
19109            write!(f, "{:#x}", remaining)?;
19110        } else if first {
19111            f.write_str("(empty)")?;
19112        }
19113        Ok(())
19114    }
19115}
19116///[`VkSemaphoreWaitFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitFlagBits.html)
19117#[repr(transparent)]
19118#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19119#[doc(alias = "VkSemaphoreWaitFlagBits")]
19120pub struct SemaphoreWaitFlagBits(u32);
19121impl SemaphoreWaitFlagBits {
19122    #[inline]
19123    pub const fn empty() -> Self {
19124        Self(0u32)
19125    }
19126    #[inline]
19127    pub const fn from_raw(value: u32) -> Self {
19128        Self(value)
19129    }
19130    #[inline]
19131    pub const fn as_raw(self) -> u32 {
19132        self.0
19133    }
19134    #[inline]
19135    pub const fn is_empty(self) -> bool {
19136        self.0 == 0u32
19137    }
19138    #[inline]
19139    pub const fn contains(self, other: Self) -> bool {
19140        (self.0 & other.0) == other.0
19141    }
19142    #[inline]
19143    pub const fn all() -> Self {
19144        Self(1u32)
19145    }
19146    ///Bit 0.
19147    pub const ANY: Self = Self(1u32);
19148}
19149impl core::ops::BitOr for SemaphoreWaitFlagBits {
19150    type Output = Self;
19151    #[inline]
19152    fn bitor(self, rhs: Self) -> Self {
19153        Self(self.0 | rhs.0)
19154    }
19155}
19156impl core::ops::BitOrAssign for SemaphoreWaitFlagBits {
19157    #[inline]
19158    fn bitor_assign(&mut self, rhs: Self) {
19159        self.0 |= rhs.0;
19160    }
19161}
19162impl core::ops::BitAnd for SemaphoreWaitFlagBits {
19163    type Output = Self;
19164    #[inline]
19165    fn bitand(self, rhs: Self) -> Self {
19166        Self(self.0 & rhs.0)
19167    }
19168}
19169impl core::ops::BitAndAssign for SemaphoreWaitFlagBits {
19170    #[inline]
19171    fn bitand_assign(&mut self, rhs: Self) {
19172        self.0 &= rhs.0;
19173    }
19174}
19175impl core::ops::BitXor for SemaphoreWaitFlagBits {
19176    type Output = Self;
19177    #[inline]
19178    fn bitxor(self, rhs: Self) -> Self {
19179        Self(self.0 ^ rhs.0)
19180    }
19181}
19182impl core::ops::BitXorAssign for SemaphoreWaitFlagBits {
19183    #[inline]
19184    fn bitxor_assign(&mut self, rhs: Self) {
19185        self.0 ^= rhs.0;
19186    }
19187}
19188impl core::ops::Not for SemaphoreWaitFlagBits {
19189    type Output = Self;
19190    #[inline]
19191    fn not(self) -> Self {
19192        Self(!self.0)
19193    }
19194}
19195impl core::fmt::Debug for SemaphoreWaitFlagBits {
19196    #[allow(unused_mut, unused_variables)]
19197    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19198        let mut first = true;
19199        let mut remaining = self.0;
19200        if remaining & Self::ANY.0 != 0 {
19201            if !first {
19202                f.write_str(" | ")?;
19203            }
19204            f.write_str("ANY")?;
19205            remaining &= !Self::ANY.0;
19206            first = false;
19207        }
19208        if remaining != 0u32 {
19209            if !first {
19210                f.write_str(" | ")?;
19211            }
19212            write!(f, "{:#x}", remaining)?;
19213        } else if first {
19214            f.write_str("(empty)")?;
19215        }
19216        Ok(())
19217    }
19218}
19219///[`VkShaderCorePropertiesFlagBitsAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCorePropertiesFlagBitsAMD.html)
19220#[repr(transparent)]
19221#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19222#[doc(alias = "VkShaderCorePropertiesFlagBitsAMD")]
19223pub struct ShaderCorePropertiesFlagBitsAMD(u32);
19224impl ShaderCorePropertiesFlagBitsAMD {
19225    #[inline]
19226    pub const fn empty() -> Self {
19227        Self(0u32)
19228    }
19229    #[inline]
19230    pub const fn from_raw(value: u32) -> Self {
19231        Self(value)
19232    }
19233    #[inline]
19234    pub const fn as_raw(self) -> u32 {
19235        self.0
19236    }
19237    #[inline]
19238    pub const fn is_empty(self) -> bool {
19239        self.0 == 0u32
19240    }
19241    #[inline]
19242    pub const fn contains(self, other: Self) -> bool {
19243        (self.0 & other.0) == other.0
19244    }
19245    #[inline]
19246    pub const fn all() -> Self {
19247        Self(0u32)
19248    }
19249}
19250impl core::ops::BitOr for ShaderCorePropertiesFlagBitsAMD {
19251    type Output = Self;
19252    #[inline]
19253    fn bitor(self, rhs: Self) -> Self {
19254        Self(self.0 | rhs.0)
19255    }
19256}
19257impl core::ops::BitOrAssign for ShaderCorePropertiesFlagBitsAMD {
19258    #[inline]
19259    fn bitor_assign(&mut self, rhs: Self) {
19260        self.0 |= rhs.0;
19261    }
19262}
19263impl core::ops::BitAnd for ShaderCorePropertiesFlagBitsAMD {
19264    type Output = Self;
19265    #[inline]
19266    fn bitand(self, rhs: Self) -> Self {
19267        Self(self.0 & rhs.0)
19268    }
19269}
19270impl core::ops::BitAndAssign for ShaderCorePropertiesFlagBitsAMD {
19271    #[inline]
19272    fn bitand_assign(&mut self, rhs: Self) {
19273        self.0 &= rhs.0;
19274    }
19275}
19276impl core::ops::BitXor for ShaderCorePropertiesFlagBitsAMD {
19277    type Output = Self;
19278    #[inline]
19279    fn bitxor(self, rhs: Self) -> Self {
19280        Self(self.0 ^ rhs.0)
19281    }
19282}
19283impl core::ops::BitXorAssign for ShaderCorePropertiesFlagBitsAMD {
19284    #[inline]
19285    fn bitxor_assign(&mut self, rhs: Self) {
19286        self.0 ^= rhs.0;
19287    }
19288}
19289impl core::ops::Not for ShaderCorePropertiesFlagBitsAMD {
19290    type Output = Self;
19291    #[inline]
19292    fn not(self) -> Self {
19293        Self(!self.0)
19294    }
19295}
19296impl core::fmt::Debug for ShaderCorePropertiesFlagBitsAMD {
19297    #[allow(unused_mut, unused_variables)]
19298    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19299        let mut first = true;
19300        let mut remaining = self.0;
19301        if remaining != 0u32 {
19302            if !first {
19303                f.write_str(" | ")?;
19304            }
19305            write!(f, "{:#x}", remaining)?;
19306        } else if first {
19307            f.write_str("(empty)")?;
19308        }
19309        Ok(())
19310    }
19311}
19312///[`VkShaderCreateFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagBitsEXT.html)
19313#[repr(transparent)]
19314#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19315#[doc(alias = "VkShaderCreateFlagBitsEXT")]
19316pub struct ShaderCreateFlagBitsEXT(u32);
19317impl ShaderCreateFlagBitsEXT {
19318    #[inline]
19319    pub const fn empty() -> Self {
19320        Self(0u32)
19321    }
19322    #[inline]
19323    pub const fn from_raw(value: u32) -> Self {
19324        Self(value)
19325    }
19326    #[inline]
19327    pub const fn as_raw(self) -> u32 {
19328        self.0
19329    }
19330    #[inline]
19331    pub const fn is_empty(self) -> bool {
19332        self.0 == 0u32
19333    }
19334    #[inline]
19335    pub const fn contains(self, other: Self) -> bool {
19336        (self.0 & other.0) == other.0
19337    }
19338    #[inline]
19339    pub const fn all() -> Self {
19340        Self(36095u32)
19341    }
19342    ///Bit 0.
19343    pub const LINK_STAGE: Self = Self(1u32);
19344    ///Bit 10.
19345    pub const DESCRIPTOR_HEAP: Self = Self(1024u32);
19346    ///Bit 11.
19347    pub const INSTRUMENT_SHADER_BIT: Self = Self(2048u32);
19348    ///Bit 1.
19349    pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(2u32);
19350    ///Bit 2.
19351    pub const REQUIRE_FULL_SUBGROUPS: Self = Self(4u32);
19352    ///Bit 3.
19353    pub const NO_TASK_SHADER: Self = Self(8u32);
19354    ///Bit 4.
19355    pub const DISPATCH_BASE: Self = Self(16u32);
19356    ///Bit 5.
19357    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(32u32);
19358    ///Bit 6.
19359    pub const FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(64u32);
19360    ///Bit 7.
19361    pub const INDIRECT_BINDABLE: Self = Self(128u32);
19362    ///Bit 15.
19363    pub const _64_BIT_INDEXING: Self = Self(32768u32);
19364}
19365impl core::ops::BitOr for ShaderCreateFlagBitsEXT {
19366    type Output = Self;
19367    #[inline]
19368    fn bitor(self, rhs: Self) -> Self {
19369        Self(self.0 | rhs.0)
19370    }
19371}
19372impl core::ops::BitOrAssign for ShaderCreateFlagBitsEXT {
19373    #[inline]
19374    fn bitor_assign(&mut self, rhs: Self) {
19375        self.0 |= rhs.0;
19376    }
19377}
19378impl core::ops::BitAnd for ShaderCreateFlagBitsEXT {
19379    type Output = Self;
19380    #[inline]
19381    fn bitand(self, rhs: Self) -> Self {
19382        Self(self.0 & rhs.0)
19383    }
19384}
19385impl core::ops::BitAndAssign for ShaderCreateFlagBitsEXT {
19386    #[inline]
19387    fn bitand_assign(&mut self, rhs: Self) {
19388        self.0 &= rhs.0;
19389    }
19390}
19391impl core::ops::BitXor for ShaderCreateFlagBitsEXT {
19392    type Output = Self;
19393    #[inline]
19394    fn bitxor(self, rhs: Self) -> Self {
19395        Self(self.0 ^ rhs.0)
19396    }
19397}
19398impl core::ops::BitXorAssign for ShaderCreateFlagBitsEXT {
19399    #[inline]
19400    fn bitxor_assign(&mut self, rhs: Self) {
19401        self.0 ^= rhs.0;
19402    }
19403}
19404impl core::ops::Not for ShaderCreateFlagBitsEXT {
19405    type Output = Self;
19406    #[inline]
19407    fn not(self) -> Self {
19408        Self(!self.0)
19409    }
19410}
19411impl core::fmt::Debug for ShaderCreateFlagBitsEXT {
19412    #[allow(unused_mut, unused_variables)]
19413    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19414        let mut first = true;
19415        let mut remaining = self.0;
19416        if remaining & Self::LINK_STAGE.0 != 0 {
19417            if !first {
19418                f.write_str(" | ")?;
19419            }
19420            f.write_str("LINK_STAGE")?;
19421            remaining &= !Self::LINK_STAGE.0;
19422            first = false;
19423        }
19424        if remaining & Self::DESCRIPTOR_HEAP.0 != 0 {
19425            if !first {
19426                f.write_str(" | ")?;
19427            }
19428            f.write_str("DESCRIPTOR_HEAP")?;
19429            remaining &= !Self::DESCRIPTOR_HEAP.0;
19430            first = false;
19431        }
19432        if remaining & Self::INSTRUMENT_SHADER_BIT.0 != 0 {
19433            if !first {
19434                f.write_str(" | ")?;
19435            }
19436            f.write_str("INSTRUMENT_SHADER_BIT")?;
19437            remaining &= !Self::INSTRUMENT_SHADER_BIT.0;
19438            first = false;
19439        }
19440        if remaining & Self::ALLOW_VARYING_SUBGROUP_SIZE.0 != 0 {
19441            if !first {
19442                f.write_str(" | ")?;
19443            }
19444            f.write_str("ALLOW_VARYING_SUBGROUP_SIZE")?;
19445            remaining &= !Self::ALLOW_VARYING_SUBGROUP_SIZE.0;
19446            first = false;
19447        }
19448        if remaining & Self::REQUIRE_FULL_SUBGROUPS.0 != 0 {
19449            if !first {
19450                f.write_str(" | ")?;
19451            }
19452            f.write_str("REQUIRE_FULL_SUBGROUPS")?;
19453            remaining &= !Self::REQUIRE_FULL_SUBGROUPS.0;
19454            first = false;
19455        }
19456        if remaining & Self::NO_TASK_SHADER.0 != 0 {
19457            if !first {
19458                f.write_str(" | ")?;
19459            }
19460            f.write_str("NO_TASK_SHADER")?;
19461            remaining &= !Self::NO_TASK_SHADER.0;
19462            first = false;
19463        }
19464        if remaining & Self::DISPATCH_BASE.0 != 0 {
19465            if !first {
19466                f.write_str(" | ")?;
19467            }
19468            f.write_str("DISPATCH_BASE")?;
19469            remaining &= !Self::DISPATCH_BASE.0;
19470            first = false;
19471        }
19472        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
19473            if !first {
19474                f.write_str(" | ")?;
19475            }
19476            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT")?;
19477            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0;
19478            first = false;
19479        }
19480        if remaining & Self::FRAGMENT_DENSITY_MAP_ATTACHMENT.0 != 0 {
19481            if !first {
19482                f.write_str(" | ")?;
19483            }
19484            f.write_str("FRAGMENT_DENSITY_MAP_ATTACHMENT")?;
19485            remaining &= !Self::FRAGMENT_DENSITY_MAP_ATTACHMENT.0;
19486            first = false;
19487        }
19488        if remaining & Self::INDIRECT_BINDABLE.0 != 0 {
19489            if !first {
19490                f.write_str(" | ")?;
19491            }
19492            f.write_str("INDIRECT_BINDABLE")?;
19493            remaining &= !Self::INDIRECT_BINDABLE.0;
19494            first = false;
19495        }
19496        if remaining & Self::_64_BIT_INDEXING.0 != 0 {
19497            if !first {
19498                f.write_str(" | ")?;
19499            }
19500            f.write_str("_64_BIT_INDEXING")?;
19501            remaining &= !Self::_64_BIT_INDEXING.0;
19502            first = false;
19503        }
19504        if remaining != 0u32 {
19505            if !first {
19506                f.write_str(" | ")?;
19507            }
19508            write!(f, "{:#x}", remaining)?;
19509        } else if first {
19510            f.write_str("(empty)")?;
19511        }
19512        Ok(())
19513    }
19514}
19515///[`VkShaderModuleCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleCreateFlagBits.html)
19516#[repr(transparent)]
19517#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19518#[doc(alias = "VkShaderModuleCreateFlagBits")]
19519pub struct ShaderModuleCreateFlagBits(u32);
19520impl ShaderModuleCreateFlagBits {
19521    #[inline]
19522    pub const fn empty() -> Self {
19523        Self(0u32)
19524    }
19525    #[inline]
19526    pub const fn from_raw(value: u32) -> Self {
19527        Self(value)
19528    }
19529    #[inline]
19530    pub const fn as_raw(self) -> u32 {
19531        self.0
19532    }
19533    #[inline]
19534    pub const fn is_empty(self) -> bool {
19535        self.0 == 0u32
19536    }
19537    #[inline]
19538    pub const fn contains(self, other: Self) -> bool {
19539        (self.0 & other.0) == other.0
19540    }
19541    #[inline]
19542    pub const fn all() -> Self {
19543        Self(0u32)
19544    }
19545}
19546impl core::ops::BitOr for ShaderModuleCreateFlagBits {
19547    type Output = Self;
19548    #[inline]
19549    fn bitor(self, rhs: Self) -> Self {
19550        Self(self.0 | rhs.0)
19551    }
19552}
19553impl core::ops::BitOrAssign for ShaderModuleCreateFlagBits {
19554    #[inline]
19555    fn bitor_assign(&mut self, rhs: Self) {
19556        self.0 |= rhs.0;
19557    }
19558}
19559impl core::ops::BitAnd for ShaderModuleCreateFlagBits {
19560    type Output = Self;
19561    #[inline]
19562    fn bitand(self, rhs: Self) -> Self {
19563        Self(self.0 & rhs.0)
19564    }
19565}
19566impl core::ops::BitAndAssign for ShaderModuleCreateFlagBits {
19567    #[inline]
19568    fn bitand_assign(&mut self, rhs: Self) {
19569        self.0 &= rhs.0;
19570    }
19571}
19572impl core::ops::BitXor for ShaderModuleCreateFlagBits {
19573    type Output = Self;
19574    #[inline]
19575    fn bitxor(self, rhs: Self) -> Self {
19576        Self(self.0 ^ rhs.0)
19577    }
19578}
19579impl core::ops::BitXorAssign for ShaderModuleCreateFlagBits {
19580    #[inline]
19581    fn bitxor_assign(&mut self, rhs: Self) {
19582        self.0 ^= rhs.0;
19583    }
19584}
19585impl core::ops::Not for ShaderModuleCreateFlagBits {
19586    type Output = Self;
19587    #[inline]
19588    fn not(self) -> Self {
19589        Self(!self.0)
19590    }
19591}
19592impl core::fmt::Debug for ShaderModuleCreateFlagBits {
19593    #[allow(unused_mut, unused_variables)]
19594    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19595        let mut first = true;
19596        let mut remaining = self.0;
19597        if remaining != 0u32 {
19598            if !first {
19599                f.write_str(" | ")?;
19600            }
19601            write!(f, "{:#x}", remaining)?;
19602        } else if first {
19603            f.write_str("(empty)")?;
19604        }
19605        Ok(())
19606    }
19607}
19608///[`VkShaderStageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderStageFlagBits.html)
19609#[repr(transparent)]
19610#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19611#[doc(alias = "VkShaderStageFlagBits")]
19612pub struct ShaderStageFlagBits(u32);
19613impl ShaderStageFlagBits {
19614    #[inline]
19615    pub const fn empty() -> Self {
19616        Self(0u32)
19617    }
19618    #[inline]
19619    pub const fn from_raw(value: u32) -> Self {
19620        Self(value)
19621    }
19622    #[inline]
19623    pub const fn as_raw(self) -> u32 {
19624        self.0
19625    }
19626    #[inline]
19627    pub const fn is_empty(self) -> bool {
19628        self.0 == 0u32
19629    }
19630    #[inline]
19631    pub const fn contains(self, other: Self) -> bool {
19632        (self.0 & other.0) == other.0
19633    }
19634    #[inline]
19635    pub const fn all() -> Self {
19636        Self(2147483647u32)
19637    }
19638    ///Bit 0.
19639    pub const VERTEX: Self = Self(1u32);
19640    ///Bit 1.
19641    pub const TESSELLATION_CONTROL: Self = Self(2u32);
19642    ///Bit 2.
19643    pub const TESSELLATION_EVALUATION: Self = Self(4u32);
19644    ///Bit 3.
19645    pub const GEOMETRY: Self = Self(8u32);
19646    ///Bit 4.
19647    pub const FRAGMENT: Self = Self(16u32);
19648    ///Bit 5.
19649    pub const COMPUTE: Self = Self(32u32);
19650    pub const ALL_GRAPHICS: Self = Self(31u32);
19651    pub const ALL: Self = Self(2147483647u32);
19652    ///Bit 8.
19653    pub const RAYGEN: Self = Self(256u32);
19654    ///Bit 9.
19655    pub const ANY_HIT: Self = Self(512u32);
19656    ///Bit 10.
19657    pub const CLOSEST_HIT: Self = Self(1024u32);
19658    ///Bit 11.
19659    pub const MISS: Self = Self(2048u32);
19660    ///Bit 12.
19661    pub const INTERSECTION: Self = Self(4096u32);
19662    ///Bit 13.
19663    pub const CALLABLE: Self = Self(8192u32);
19664    ///Bit 14.
19665    pub const SUBPASS_SHADING_BIT: Self = Self(16384u32);
19666    ///Bit 19.
19667    pub const CLUSTER_CULLING_BIT: Self = Self(524288u32);
19668}
19669impl core::ops::BitOr for ShaderStageFlagBits {
19670    type Output = Self;
19671    #[inline]
19672    fn bitor(self, rhs: Self) -> Self {
19673        Self(self.0 | rhs.0)
19674    }
19675}
19676impl core::ops::BitOrAssign for ShaderStageFlagBits {
19677    #[inline]
19678    fn bitor_assign(&mut self, rhs: Self) {
19679        self.0 |= rhs.0;
19680    }
19681}
19682impl core::ops::BitAnd for ShaderStageFlagBits {
19683    type Output = Self;
19684    #[inline]
19685    fn bitand(self, rhs: Self) -> Self {
19686        Self(self.0 & rhs.0)
19687    }
19688}
19689impl core::ops::BitAndAssign for ShaderStageFlagBits {
19690    #[inline]
19691    fn bitand_assign(&mut self, rhs: Self) {
19692        self.0 &= rhs.0;
19693    }
19694}
19695impl core::ops::BitXor for ShaderStageFlagBits {
19696    type Output = Self;
19697    #[inline]
19698    fn bitxor(self, rhs: Self) -> Self {
19699        Self(self.0 ^ rhs.0)
19700    }
19701}
19702impl core::ops::BitXorAssign for ShaderStageFlagBits {
19703    #[inline]
19704    fn bitxor_assign(&mut self, rhs: Self) {
19705        self.0 ^= rhs.0;
19706    }
19707}
19708impl core::ops::Not for ShaderStageFlagBits {
19709    type Output = Self;
19710    #[inline]
19711    fn not(self) -> Self {
19712        Self(!self.0)
19713    }
19714}
19715impl core::fmt::Debug for ShaderStageFlagBits {
19716    #[allow(unused_mut, unused_variables)]
19717    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19718        let mut first = true;
19719        let mut remaining = self.0;
19720        if remaining & Self::VERTEX.0 != 0 {
19721            if !first {
19722                f.write_str(" | ")?;
19723            }
19724            f.write_str("VERTEX")?;
19725            remaining &= !Self::VERTEX.0;
19726            first = false;
19727        }
19728        if remaining & Self::TESSELLATION_CONTROL.0 != 0 {
19729            if !first {
19730                f.write_str(" | ")?;
19731            }
19732            f.write_str("TESSELLATION_CONTROL")?;
19733            remaining &= !Self::TESSELLATION_CONTROL.0;
19734            first = false;
19735        }
19736        if remaining & Self::TESSELLATION_EVALUATION.0 != 0 {
19737            if !first {
19738                f.write_str(" | ")?;
19739            }
19740            f.write_str("TESSELLATION_EVALUATION")?;
19741            remaining &= !Self::TESSELLATION_EVALUATION.0;
19742            first = false;
19743        }
19744        if remaining & Self::GEOMETRY.0 != 0 {
19745            if !first {
19746                f.write_str(" | ")?;
19747            }
19748            f.write_str("GEOMETRY")?;
19749            remaining &= !Self::GEOMETRY.0;
19750            first = false;
19751        }
19752        if remaining & Self::FRAGMENT.0 != 0 {
19753            if !first {
19754                f.write_str(" | ")?;
19755            }
19756            f.write_str("FRAGMENT")?;
19757            remaining &= !Self::FRAGMENT.0;
19758            first = false;
19759        }
19760        if remaining & Self::COMPUTE.0 != 0 {
19761            if !first {
19762                f.write_str(" | ")?;
19763            }
19764            f.write_str("COMPUTE")?;
19765            remaining &= !Self::COMPUTE.0;
19766            first = false;
19767        }
19768        if remaining & Self::RAYGEN.0 != 0 {
19769            if !first {
19770                f.write_str(" | ")?;
19771            }
19772            f.write_str("RAYGEN")?;
19773            remaining &= !Self::RAYGEN.0;
19774            first = false;
19775        }
19776        if remaining & Self::ANY_HIT.0 != 0 {
19777            if !first {
19778                f.write_str(" | ")?;
19779            }
19780            f.write_str("ANY_HIT")?;
19781            remaining &= !Self::ANY_HIT.0;
19782            first = false;
19783        }
19784        if remaining & Self::CLOSEST_HIT.0 != 0 {
19785            if !first {
19786                f.write_str(" | ")?;
19787            }
19788            f.write_str("CLOSEST_HIT")?;
19789            remaining &= !Self::CLOSEST_HIT.0;
19790            first = false;
19791        }
19792        if remaining & Self::MISS.0 != 0 {
19793            if !first {
19794                f.write_str(" | ")?;
19795            }
19796            f.write_str("MISS")?;
19797            remaining &= !Self::MISS.0;
19798            first = false;
19799        }
19800        if remaining & Self::INTERSECTION.0 != 0 {
19801            if !first {
19802                f.write_str(" | ")?;
19803            }
19804            f.write_str("INTERSECTION")?;
19805            remaining &= !Self::INTERSECTION.0;
19806            first = false;
19807        }
19808        if remaining & Self::CALLABLE.0 != 0 {
19809            if !first {
19810                f.write_str(" | ")?;
19811            }
19812            f.write_str("CALLABLE")?;
19813            remaining &= !Self::CALLABLE.0;
19814            first = false;
19815        }
19816        if remaining & Self::SUBPASS_SHADING_BIT.0 != 0 {
19817            if !first {
19818                f.write_str(" | ")?;
19819            }
19820            f.write_str("SUBPASS_SHADING_BIT")?;
19821            remaining &= !Self::SUBPASS_SHADING_BIT.0;
19822            first = false;
19823        }
19824        if remaining & Self::CLUSTER_CULLING_BIT.0 != 0 {
19825            if !first {
19826                f.write_str(" | ")?;
19827            }
19828            f.write_str("CLUSTER_CULLING_BIT")?;
19829            remaining &= !Self::CLUSTER_CULLING_BIT.0;
19830            first = false;
19831        }
19832        if remaining != 0u32 {
19833            if !first {
19834                f.write_str(" | ")?;
19835            }
19836            write!(f, "{:#x}", remaining)?;
19837        } else if first {
19838            f.write_str("(empty)")?;
19839        }
19840        Ok(())
19841    }
19842}
19843///[`VkSparseImageFormatFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatFlagBits.html)
19844#[repr(transparent)]
19845#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19846#[doc(alias = "VkSparseImageFormatFlagBits")]
19847pub struct SparseImageFormatFlagBits(u32);
19848impl SparseImageFormatFlagBits {
19849    #[inline]
19850    pub const fn empty() -> Self {
19851        Self(0u32)
19852    }
19853    #[inline]
19854    pub const fn from_raw(value: u32) -> Self {
19855        Self(value)
19856    }
19857    #[inline]
19858    pub const fn as_raw(self) -> u32 {
19859        self.0
19860    }
19861    #[inline]
19862    pub const fn is_empty(self) -> bool {
19863        self.0 == 0u32
19864    }
19865    #[inline]
19866    pub const fn contains(self, other: Self) -> bool {
19867        (self.0 & other.0) == other.0
19868    }
19869    #[inline]
19870    pub const fn all() -> Self {
19871        Self(7u32)
19872    }
19873    ///Bit 0.
19874    pub const SINGLE_MIPTAIL: Self = Self(1u32);
19875    ///Bit 1.
19876    pub const ALIGNED_MIP_SIZE: Self = Self(2u32);
19877    ///Bit 2.
19878    pub const NONSTANDARD_BLOCK_SIZE: Self = Self(4u32);
19879}
19880impl core::ops::BitOr for SparseImageFormatFlagBits {
19881    type Output = Self;
19882    #[inline]
19883    fn bitor(self, rhs: Self) -> Self {
19884        Self(self.0 | rhs.0)
19885    }
19886}
19887impl core::ops::BitOrAssign for SparseImageFormatFlagBits {
19888    #[inline]
19889    fn bitor_assign(&mut self, rhs: Self) {
19890        self.0 |= rhs.0;
19891    }
19892}
19893impl core::ops::BitAnd for SparseImageFormatFlagBits {
19894    type Output = Self;
19895    #[inline]
19896    fn bitand(self, rhs: Self) -> Self {
19897        Self(self.0 & rhs.0)
19898    }
19899}
19900impl core::ops::BitAndAssign for SparseImageFormatFlagBits {
19901    #[inline]
19902    fn bitand_assign(&mut self, rhs: Self) {
19903        self.0 &= rhs.0;
19904    }
19905}
19906impl core::ops::BitXor for SparseImageFormatFlagBits {
19907    type Output = Self;
19908    #[inline]
19909    fn bitxor(self, rhs: Self) -> Self {
19910        Self(self.0 ^ rhs.0)
19911    }
19912}
19913impl core::ops::BitXorAssign for SparseImageFormatFlagBits {
19914    #[inline]
19915    fn bitxor_assign(&mut self, rhs: Self) {
19916        self.0 ^= rhs.0;
19917    }
19918}
19919impl core::ops::Not for SparseImageFormatFlagBits {
19920    type Output = Self;
19921    #[inline]
19922    fn not(self) -> Self {
19923        Self(!self.0)
19924    }
19925}
19926impl core::fmt::Debug for SparseImageFormatFlagBits {
19927    #[allow(unused_mut, unused_variables)]
19928    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19929        let mut first = true;
19930        let mut remaining = self.0;
19931        if remaining & Self::SINGLE_MIPTAIL.0 != 0 {
19932            if !first {
19933                f.write_str(" | ")?;
19934            }
19935            f.write_str("SINGLE_MIPTAIL")?;
19936            remaining &= !Self::SINGLE_MIPTAIL.0;
19937            first = false;
19938        }
19939        if remaining & Self::ALIGNED_MIP_SIZE.0 != 0 {
19940            if !first {
19941                f.write_str(" | ")?;
19942            }
19943            f.write_str("ALIGNED_MIP_SIZE")?;
19944            remaining &= !Self::ALIGNED_MIP_SIZE.0;
19945            first = false;
19946        }
19947        if remaining & Self::NONSTANDARD_BLOCK_SIZE.0 != 0 {
19948            if !first {
19949                f.write_str(" | ")?;
19950            }
19951            f.write_str("NONSTANDARD_BLOCK_SIZE")?;
19952            remaining &= !Self::NONSTANDARD_BLOCK_SIZE.0;
19953            first = false;
19954        }
19955        if remaining != 0u32 {
19956            if !first {
19957                f.write_str(" | ")?;
19958            }
19959            write!(f, "{:#x}", remaining)?;
19960        } else if first {
19961            f.write_str("(empty)")?;
19962        }
19963        Ok(())
19964    }
19965}
19966///[`VkSparseMemoryBindFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBindFlagBits.html)
19967#[repr(transparent)]
19968#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19969#[doc(alias = "VkSparseMemoryBindFlagBits")]
19970pub struct SparseMemoryBindFlagBits(u32);
19971impl SparseMemoryBindFlagBits {
19972    #[inline]
19973    pub const fn empty() -> Self {
19974        Self(0u32)
19975    }
19976    #[inline]
19977    pub const fn from_raw(value: u32) -> Self {
19978        Self(value)
19979    }
19980    #[inline]
19981    pub const fn as_raw(self) -> u32 {
19982        self.0
19983    }
19984    #[inline]
19985    pub const fn is_empty(self) -> bool {
19986        self.0 == 0u32
19987    }
19988    #[inline]
19989    pub const fn contains(self, other: Self) -> bool {
19990        (self.0 & other.0) == other.0
19991    }
19992    #[inline]
19993    pub const fn all() -> Self {
19994        Self(1u32)
19995    }
19996    ///Bit 0.
19997    pub const METADATA: Self = Self(1u32);
19998}
19999impl core::ops::BitOr for SparseMemoryBindFlagBits {
20000    type Output = Self;
20001    #[inline]
20002    fn bitor(self, rhs: Self) -> Self {
20003        Self(self.0 | rhs.0)
20004    }
20005}
20006impl core::ops::BitOrAssign for SparseMemoryBindFlagBits {
20007    #[inline]
20008    fn bitor_assign(&mut self, rhs: Self) {
20009        self.0 |= rhs.0;
20010    }
20011}
20012impl core::ops::BitAnd for SparseMemoryBindFlagBits {
20013    type Output = Self;
20014    #[inline]
20015    fn bitand(self, rhs: Self) -> Self {
20016        Self(self.0 & rhs.0)
20017    }
20018}
20019impl core::ops::BitAndAssign for SparseMemoryBindFlagBits {
20020    #[inline]
20021    fn bitand_assign(&mut self, rhs: Self) {
20022        self.0 &= rhs.0;
20023    }
20024}
20025impl core::ops::BitXor for SparseMemoryBindFlagBits {
20026    type Output = Self;
20027    #[inline]
20028    fn bitxor(self, rhs: Self) -> Self {
20029        Self(self.0 ^ rhs.0)
20030    }
20031}
20032impl core::ops::BitXorAssign for SparseMemoryBindFlagBits {
20033    #[inline]
20034    fn bitxor_assign(&mut self, rhs: Self) {
20035        self.0 ^= rhs.0;
20036    }
20037}
20038impl core::ops::Not for SparseMemoryBindFlagBits {
20039    type Output = Self;
20040    #[inline]
20041    fn not(self) -> Self {
20042        Self(!self.0)
20043    }
20044}
20045impl core::fmt::Debug for SparseMemoryBindFlagBits {
20046    #[allow(unused_mut, unused_variables)]
20047    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20048        let mut first = true;
20049        let mut remaining = self.0;
20050        if remaining & Self::METADATA.0 != 0 {
20051            if !first {
20052                f.write_str(" | ")?;
20053            }
20054            f.write_str("METADATA")?;
20055            remaining &= !Self::METADATA.0;
20056            first = false;
20057        }
20058        if remaining != 0u32 {
20059            if !first {
20060                f.write_str(" | ")?;
20061            }
20062            write!(f, "{:#x}", remaining)?;
20063        } else if first {
20064            f.write_str("(empty)")?;
20065        }
20066        Ok(())
20067    }
20068}
20069///[`VkSpirvResourceTypeFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpirvResourceTypeFlagBitsEXT.html)
20070#[repr(transparent)]
20071#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
20072#[doc(alias = "VkSpirvResourceTypeFlagBitsEXT")]
20073pub struct SpirvResourceTypeFlagBitsEXT(u32);
20074impl SpirvResourceTypeFlagBitsEXT {
20075    #[inline]
20076    pub const fn empty() -> Self {
20077        Self(0u32)
20078    }
20079    #[inline]
20080    pub const fn from_raw(value: u32) -> Self {
20081        Self(value)
20082    }
20083    #[inline]
20084    pub const fn as_raw(self) -> u32 {
20085        self.0
20086    }
20087    #[inline]
20088    pub const fn is_empty(self) -> bool {
20089        self.0 == 0u32
20090    }
20091    #[inline]
20092    pub const fn contains(self, other: Self) -> bool {
20093        (self.0 & other.0) == other.0
20094    }
20095    #[inline]
20096    pub const fn all() -> Self {
20097        Self(2147483647u32)
20098    }
20099    pub const ALL: Self = Self(2147483647u32);
20100    ///Bit 0.
20101    pub const SAMPLER: Self = Self(1u32);
20102    ///Bit 1.
20103    pub const SAMPLED_IMAGE: Self = Self(2u32);
20104    ///Bit 2.
20105    pub const READ_ONLY_IMAGE: Self = Self(4u32);
20106    ///Bit 3.
20107    pub const READ_WRITE_IMAGE: Self = Self(8u32);
20108    ///Bit 4.
20109    pub const COMBINED_SAMPLED_IMAGE: Self = Self(16u32);
20110    ///Bit 5.
20111    pub const UNIFORM_BUFFER: Self = Self(32u32);
20112    ///Bit 6.
20113    pub const READ_ONLY_STORAGE_BUFFER: Self = Self(64u32);
20114    ///Bit 7.
20115    pub const READ_WRITE_STORAGE_BUFFER: Self = Self(128u32);
20116    ///Bit 8.
20117    pub const ACCELERATION_STRUCTURE: Self = Self(256u32);
20118    ///Bit 9.
20119    pub const TENSOR_BIT: Self = Self(512u32);
20120}
20121impl core::ops::BitOr for SpirvResourceTypeFlagBitsEXT {
20122    type Output = Self;
20123    #[inline]
20124    fn bitor(self, rhs: Self) -> Self {
20125        Self(self.0 | rhs.0)
20126    }
20127}
20128impl core::ops::BitOrAssign for SpirvResourceTypeFlagBitsEXT {
20129    #[inline]
20130    fn bitor_assign(&mut self, rhs: Self) {
20131        self.0 |= rhs.0;
20132    }
20133}
20134impl core::ops::BitAnd for SpirvResourceTypeFlagBitsEXT {
20135    type Output = Self;
20136    #[inline]
20137    fn bitand(self, rhs: Self) -> Self {
20138        Self(self.0 & rhs.0)
20139    }
20140}
20141impl core::ops::BitAndAssign for SpirvResourceTypeFlagBitsEXT {
20142    #[inline]
20143    fn bitand_assign(&mut self, rhs: Self) {
20144        self.0 &= rhs.0;
20145    }
20146}
20147impl core::ops::BitXor for SpirvResourceTypeFlagBitsEXT {
20148    type Output = Self;
20149    #[inline]
20150    fn bitxor(self, rhs: Self) -> Self {
20151        Self(self.0 ^ rhs.0)
20152    }
20153}
20154impl core::ops::BitXorAssign for SpirvResourceTypeFlagBitsEXT {
20155    #[inline]
20156    fn bitxor_assign(&mut self, rhs: Self) {
20157        self.0 ^= rhs.0;
20158    }
20159}
20160impl core::ops::Not for SpirvResourceTypeFlagBitsEXT {
20161    type Output = Self;
20162    #[inline]
20163    fn not(self) -> Self {
20164        Self(!self.0)
20165    }
20166}
20167impl core::fmt::Debug for SpirvResourceTypeFlagBitsEXT {
20168    #[allow(unused_mut, unused_variables)]
20169    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20170        let mut first = true;
20171        let mut remaining = self.0;
20172        if remaining & Self::SAMPLER.0 != 0 {
20173            if !first {
20174                f.write_str(" | ")?;
20175            }
20176            f.write_str("SAMPLER")?;
20177            remaining &= !Self::SAMPLER.0;
20178            first = false;
20179        }
20180        if remaining & Self::SAMPLED_IMAGE.0 != 0 {
20181            if !first {
20182                f.write_str(" | ")?;
20183            }
20184            f.write_str("SAMPLED_IMAGE")?;
20185            remaining &= !Self::SAMPLED_IMAGE.0;
20186            first = false;
20187        }
20188        if remaining & Self::READ_ONLY_IMAGE.0 != 0 {
20189            if !first {
20190                f.write_str(" | ")?;
20191            }
20192            f.write_str("READ_ONLY_IMAGE")?;
20193            remaining &= !Self::READ_ONLY_IMAGE.0;
20194            first = false;
20195        }
20196        if remaining & Self::READ_WRITE_IMAGE.0 != 0 {
20197            if !first {
20198                f.write_str(" | ")?;
20199            }
20200            f.write_str("READ_WRITE_IMAGE")?;
20201            remaining &= !Self::READ_WRITE_IMAGE.0;
20202            first = false;
20203        }
20204        if remaining & Self::COMBINED_SAMPLED_IMAGE.0 != 0 {
20205            if !first {
20206                f.write_str(" | ")?;
20207            }
20208            f.write_str("COMBINED_SAMPLED_IMAGE")?;
20209            remaining &= !Self::COMBINED_SAMPLED_IMAGE.0;
20210            first = false;
20211        }
20212        if remaining & Self::UNIFORM_BUFFER.0 != 0 {
20213            if !first {
20214                f.write_str(" | ")?;
20215            }
20216            f.write_str("UNIFORM_BUFFER")?;
20217            remaining &= !Self::UNIFORM_BUFFER.0;
20218            first = false;
20219        }
20220        if remaining & Self::READ_ONLY_STORAGE_BUFFER.0 != 0 {
20221            if !first {
20222                f.write_str(" | ")?;
20223            }
20224            f.write_str("READ_ONLY_STORAGE_BUFFER")?;
20225            remaining &= !Self::READ_ONLY_STORAGE_BUFFER.0;
20226            first = false;
20227        }
20228        if remaining & Self::READ_WRITE_STORAGE_BUFFER.0 != 0 {
20229            if !first {
20230                f.write_str(" | ")?;
20231            }
20232            f.write_str("READ_WRITE_STORAGE_BUFFER")?;
20233            remaining &= !Self::READ_WRITE_STORAGE_BUFFER.0;
20234            first = false;
20235        }
20236        if remaining & Self::ACCELERATION_STRUCTURE.0 != 0 {
20237            if !first {
20238                f.write_str(" | ")?;
20239            }
20240            f.write_str("ACCELERATION_STRUCTURE")?;
20241            remaining &= !Self::ACCELERATION_STRUCTURE.0;
20242            first = false;
20243        }
20244        if remaining & Self::TENSOR_BIT.0 != 0 {
20245            if !first {
20246                f.write_str(" | ")?;
20247            }
20248            f.write_str("TENSOR_BIT")?;
20249            remaining &= !Self::TENSOR_BIT.0;
20250            first = false;
20251        }
20252        if remaining != 0u32 {
20253            if !first {
20254                f.write_str(" | ")?;
20255            }
20256            write!(f, "{:#x}", remaining)?;
20257        } else if first {
20258            f.write_str("(empty)")?;
20259        }
20260        Ok(())
20261    }
20262}
20263///[`VkStencilFaceFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilFaceFlagBits.html)
20264#[repr(transparent)]
20265#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
20266#[doc(alias = "VkStencilFaceFlagBits")]
20267pub struct StencilFaceFlagBits(u32);
20268impl StencilFaceFlagBits {
20269    #[inline]
20270    pub const fn empty() -> Self {
20271        Self(0u32)
20272    }
20273    #[inline]
20274    pub const fn from_raw(value: u32) -> Self {
20275        Self(value)
20276    }
20277    #[inline]
20278    pub const fn as_raw(self) -> u32 {
20279        self.0
20280    }
20281    #[inline]
20282    pub const fn is_empty(self) -> bool {
20283        self.0 == 0u32
20284    }
20285    #[inline]
20286    pub const fn contains(self, other: Self) -> bool {
20287        (self.0 & other.0) == other.0
20288    }
20289    #[inline]
20290    pub const fn all() -> Self {
20291        Self(3u32)
20292    }
20293    ///Bit 0.
20294    pub const FRONT: Self = Self(1u32);
20295    ///Bit 1.
20296    pub const BACK: Self = Self(2u32);
20297    pub const FRONT_AND_BACK: Self = Self(3u32);
20298    pub const STENCIL_FRONT_AND_BACK: Self = Self::FRONT_AND_BACK;
20299}
20300impl core::ops::BitOr for StencilFaceFlagBits {
20301    type Output = Self;
20302    #[inline]
20303    fn bitor(self, rhs: Self) -> Self {
20304        Self(self.0 | rhs.0)
20305    }
20306}
20307impl core::ops::BitOrAssign for StencilFaceFlagBits {
20308    #[inline]
20309    fn bitor_assign(&mut self, rhs: Self) {
20310        self.0 |= rhs.0;
20311    }
20312}
20313impl core::ops::BitAnd for StencilFaceFlagBits {
20314    type Output = Self;
20315    #[inline]
20316    fn bitand(self, rhs: Self) -> Self {
20317        Self(self.0 & rhs.0)
20318    }
20319}
20320impl core::ops::BitAndAssign for StencilFaceFlagBits {
20321    #[inline]
20322    fn bitand_assign(&mut self, rhs: Self) {
20323        self.0 &= rhs.0;
20324    }
20325}
20326impl core::ops::BitXor for StencilFaceFlagBits {
20327    type Output = Self;
20328    #[inline]
20329    fn bitxor(self, rhs: Self) -> Self {
20330        Self(self.0 ^ rhs.0)
20331    }
20332}
20333impl core::ops::BitXorAssign for StencilFaceFlagBits {
20334    #[inline]
20335    fn bitxor_assign(&mut self, rhs: Self) {
20336        self.0 ^= rhs.0;
20337    }
20338}
20339impl core::ops::Not for StencilFaceFlagBits {
20340    type Output = Self;
20341    #[inline]
20342    fn not(self) -> Self {
20343        Self(!self.0)
20344    }
20345}
20346impl core::fmt::Debug for StencilFaceFlagBits {
20347    #[allow(unused_mut, unused_variables)]
20348    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20349        let mut first = true;
20350        let mut remaining = self.0;
20351        if remaining & Self::FRONT.0 != 0 {
20352            if !first {
20353                f.write_str(" | ")?;
20354            }
20355            f.write_str("FRONT")?;
20356            remaining &= !Self::FRONT.0;
20357            first = false;
20358        }
20359        if remaining & Self::BACK.0 != 0 {
20360            if !first {
20361                f.write_str(" | ")?;
20362            }
20363            f.write_str("BACK")?;
20364            remaining &= !Self::BACK.0;
20365            first = false;
20366        }
20367        if remaining != 0u32 {
20368            if !first {
20369                f.write_str(" | ")?;
20370            }
20371            write!(f, "{:#x}", remaining)?;
20372        } else if first {
20373            f.write_str("(empty)")?;
20374        }
20375        Ok(())
20376    }
20377}
20378///[`VkSubgroupFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubgroupFeatureFlagBits.html)
20379#[repr(transparent)]
20380#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
20381#[doc(alias = "VkSubgroupFeatureFlagBits")]
20382pub struct SubgroupFeatureFlagBits(u32);
20383impl SubgroupFeatureFlagBits {
20384    #[inline]
20385    pub const fn empty() -> Self {
20386        Self(0u32)
20387    }
20388    #[inline]
20389    pub const fn from_raw(value: u32) -> Self {
20390        Self(value)
20391    }
20392    #[inline]
20393    pub const fn as_raw(self) -> u32 {
20394        self.0
20395    }
20396    #[inline]
20397    pub const fn is_empty(self) -> bool {
20398        self.0 == 0u32
20399    }
20400    #[inline]
20401    pub const fn contains(self, other: Self) -> bool {
20402        (self.0 & other.0) == other.0
20403    }
20404    #[inline]
20405    pub const fn all() -> Self {
20406        Self(1791u32)
20407    }
20408    ///Bit 0.
20409    pub const BASIC: Self = Self(1u32);
20410    ///Bit 1.
20411    pub const VOTE: Self = Self(2u32);
20412    ///Bit 2.
20413    pub const ARITHMETIC: Self = Self(4u32);
20414    ///Bit 3.
20415    pub const BALLOT: Self = Self(8u32);
20416    ///Bit 4.
20417    pub const SHUFFLE: Self = Self(16u32);
20418    ///Bit 5.
20419    pub const SHUFFLE_RELATIVE: Self = Self(32u32);
20420    ///Bit 6.
20421    pub const CLUSTERED: Self = Self(64u32);
20422    ///Bit 7.
20423    pub const QUAD: Self = Self(128u32);
20424    ///Bit 9.
20425    pub const ROTATE: Self = Self(512u32);
20426    ///Bit 10.
20427    pub const ROTATE_CLUSTERED: Self = Self(1024u32);
20428}
20429impl core::ops::BitOr for SubgroupFeatureFlagBits {
20430    type Output = Self;
20431    #[inline]
20432    fn bitor(self, rhs: Self) -> Self {
20433        Self(self.0 | rhs.0)
20434    }
20435}
20436impl core::ops::BitOrAssign for SubgroupFeatureFlagBits {
20437    #[inline]
20438    fn bitor_assign(&mut self, rhs: Self) {
20439        self.0 |= rhs.0;
20440    }
20441}
20442impl core::ops::BitAnd for SubgroupFeatureFlagBits {
20443    type Output = Self;
20444    #[inline]
20445    fn bitand(self, rhs: Self) -> Self {
20446        Self(self.0 & rhs.0)
20447    }
20448}
20449impl core::ops::BitAndAssign for SubgroupFeatureFlagBits {
20450    #[inline]
20451    fn bitand_assign(&mut self, rhs: Self) {
20452        self.0 &= rhs.0;
20453    }
20454}
20455impl core::ops::BitXor for SubgroupFeatureFlagBits {
20456    type Output = Self;
20457    #[inline]
20458    fn bitxor(self, rhs: Self) -> Self {
20459        Self(self.0 ^ rhs.0)
20460    }
20461}
20462impl core::ops::BitXorAssign for SubgroupFeatureFlagBits {
20463    #[inline]
20464    fn bitxor_assign(&mut self, rhs: Self) {
20465        self.0 ^= rhs.0;
20466    }
20467}
20468impl core::ops::Not for SubgroupFeatureFlagBits {
20469    type Output = Self;
20470    #[inline]
20471    fn not(self) -> Self {
20472        Self(!self.0)
20473    }
20474}
20475impl core::fmt::Debug for SubgroupFeatureFlagBits {
20476    #[allow(unused_mut, unused_variables)]
20477    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20478        let mut first = true;
20479        let mut remaining = self.0;
20480        if remaining & Self::BASIC.0 != 0 {
20481            if !first {
20482                f.write_str(" | ")?;
20483            }
20484            f.write_str("BASIC")?;
20485            remaining &= !Self::BASIC.0;
20486            first = false;
20487        }
20488        if remaining & Self::VOTE.0 != 0 {
20489            if !first {
20490                f.write_str(" | ")?;
20491            }
20492            f.write_str("VOTE")?;
20493            remaining &= !Self::VOTE.0;
20494            first = false;
20495        }
20496        if remaining & Self::ARITHMETIC.0 != 0 {
20497            if !first {
20498                f.write_str(" | ")?;
20499            }
20500            f.write_str("ARITHMETIC")?;
20501            remaining &= !Self::ARITHMETIC.0;
20502            first = false;
20503        }
20504        if remaining & Self::BALLOT.0 != 0 {
20505            if !first {
20506                f.write_str(" | ")?;
20507            }
20508            f.write_str("BALLOT")?;
20509            remaining &= !Self::BALLOT.0;
20510            first = false;
20511        }
20512        if remaining & Self::SHUFFLE.0 != 0 {
20513            if !first {
20514                f.write_str(" | ")?;
20515            }
20516            f.write_str("SHUFFLE")?;
20517            remaining &= !Self::SHUFFLE.0;
20518            first = false;
20519        }
20520        if remaining & Self::SHUFFLE_RELATIVE.0 != 0 {
20521            if !first {
20522                f.write_str(" | ")?;
20523            }
20524            f.write_str("SHUFFLE_RELATIVE")?;
20525            remaining &= !Self::SHUFFLE_RELATIVE.0;
20526            first = false;
20527        }
20528        if remaining & Self::CLUSTERED.0 != 0 {
20529            if !first {
20530                f.write_str(" | ")?;
20531            }
20532            f.write_str("CLUSTERED")?;
20533            remaining &= !Self::CLUSTERED.0;
20534            first = false;
20535        }
20536        if remaining & Self::QUAD.0 != 0 {
20537            if !first {
20538                f.write_str(" | ")?;
20539            }
20540            f.write_str("QUAD")?;
20541            remaining &= !Self::QUAD.0;
20542            first = false;
20543        }
20544        if remaining & Self::ROTATE.0 != 0 {
20545            if !first {
20546                f.write_str(" | ")?;
20547            }
20548            f.write_str("ROTATE")?;
20549            remaining &= !Self::ROTATE.0;
20550            first = false;
20551        }
20552        if remaining & Self::ROTATE_CLUSTERED.0 != 0 {
20553            if !first {
20554                f.write_str(" | ")?;
20555            }
20556            f.write_str("ROTATE_CLUSTERED")?;
20557            remaining &= !Self::ROTATE_CLUSTERED.0;
20558            first = false;
20559        }
20560        if remaining != 0u32 {
20561            if !first {
20562                f.write_str(" | ")?;
20563            }
20564            write!(f, "{:#x}", remaining)?;
20565        } else if first {
20566            f.write_str("(empty)")?;
20567        }
20568        Ok(())
20569    }
20570}
20571///[`VkSubmitFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlagBits.html)
20572#[repr(transparent)]
20573#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
20574#[doc(alias = "VkSubmitFlagBits")]
20575pub struct SubmitFlagBits(u32);
20576impl SubmitFlagBits {
20577    #[inline]
20578    pub const fn empty() -> Self {
20579        Self(0u32)
20580    }
20581    #[inline]
20582    pub const fn from_raw(value: u32) -> Self {
20583        Self(value)
20584    }
20585    #[inline]
20586    pub const fn as_raw(self) -> u32 {
20587        self.0
20588    }
20589    #[inline]
20590    pub const fn is_empty(self) -> bool {
20591        self.0 == 0u32
20592    }
20593    #[inline]
20594    pub const fn contains(self, other: Self) -> bool {
20595        (self.0 & other.0) == other.0
20596    }
20597    #[inline]
20598    pub const fn all() -> Self {
20599        Self(1u32)
20600    }
20601    ///Bit 0.
20602    pub const PROTECTED: Self = Self(1u32);
20603}
20604impl core::ops::BitOr for SubmitFlagBits {
20605    type Output = Self;
20606    #[inline]
20607    fn bitor(self, rhs: Self) -> Self {
20608        Self(self.0 | rhs.0)
20609    }
20610}
20611impl core::ops::BitOrAssign for SubmitFlagBits {
20612    #[inline]
20613    fn bitor_assign(&mut self, rhs: Self) {
20614        self.0 |= rhs.0;
20615    }
20616}
20617impl core::ops::BitAnd for SubmitFlagBits {
20618    type Output = Self;
20619    #[inline]
20620    fn bitand(self, rhs: Self) -> Self {
20621        Self(self.0 & rhs.0)
20622    }
20623}
20624impl core::ops::BitAndAssign for SubmitFlagBits {
20625    #[inline]
20626    fn bitand_assign(&mut self, rhs: Self) {
20627        self.0 &= rhs.0;
20628    }
20629}
20630impl core::ops::BitXor for SubmitFlagBits {
20631    type Output = Self;
20632    #[inline]
20633    fn bitxor(self, rhs: Self) -> Self {
20634        Self(self.0 ^ rhs.0)
20635    }
20636}
20637impl core::ops::BitXorAssign for SubmitFlagBits {
20638    #[inline]
20639    fn bitxor_assign(&mut self, rhs: Self) {
20640        self.0 ^= rhs.0;
20641    }
20642}
20643impl core::ops::Not for SubmitFlagBits {
20644    type Output = Self;
20645    #[inline]
20646    fn not(self) -> Self {
20647        Self(!self.0)
20648    }
20649}
20650impl core::fmt::Debug for SubmitFlagBits {
20651    #[allow(unused_mut, unused_variables)]
20652    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20653        let mut first = true;
20654        let mut remaining = self.0;
20655        if remaining & Self::PROTECTED.0 != 0 {
20656            if !first {
20657                f.write_str(" | ")?;
20658            }
20659            f.write_str("PROTECTED")?;
20660            remaining &= !Self::PROTECTED.0;
20661            first = false;
20662        }
20663        if remaining != 0u32 {
20664            if !first {
20665                f.write_str(" | ")?;
20666            }
20667            write!(f, "{:#x}", remaining)?;
20668        } else if first {
20669            f.write_str("(empty)")?;
20670        }
20671        Ok(())
20672    }
20673}
20674///[`VkSubpassDescriptionFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionFlagBits.html)
20675#[repr(transparent)]
20676#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
20677#[doc(alias = "VkSubpassDescriptionFlagBits")]
20678pub struct SubpassDescriptionFlagBits(u32);
20679impl SubpassDescriptionFlagBits {
20680    #[inline]
20681    pub const fn empty() -> Self {
20682        Self(0u32)
20683    }
20684    #[inline]
20685    pub const fn from_raw(value: u32) -> Self {
20686        Self(value)
20687    }
20688    #[inline]
20689    pub const fn as_raw(self) -> u32 {
20690        self.0
20691    }
20692    #[inline]
20693    pub const fn is_empty(self) -> bool {
20694        self.0 == 0u32
20695    }
20696    #[inline]
20697    pub const fn contains(self, other: Self) -> bool {
20698        (self.0 & other.0) == other.0
20699    }
20700    #[inline]
20701    pub const fn all() -> Self {
20702        Self(511u32)
20703    }
20704    ///Bit 0.
20705    pub const PER_VIEW_ATTRIBUTES_BIT: Self = Self(1u32);
20706    ///Bit 1.
20707    pub const PER_VIEW_POSITION_X_ONLY_BIT: Self = Self(2u32);
20708    pub const FRAGMENT_REGION_BIT: Self = Self::FRAGMENT_REGION;
20709    pub const SHADER_RESOLVE_BIT: Self = Self::CUSTOM_RESOLVE;
20710    ///Bit 8.
20711    pub const TILE_SHADING_APRON_BIT: Self = Self(256u32);
20712    pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS;
20713    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS;
20714    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS;
20715    ///Bit 4.
20716    pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS: Self = Self(16u32);
20717    ///Bit 5.
20718    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS: Self = Self(32u32);
20719    ///Bit 6.
20720    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS: Self = Self(64u32);
20721    ///Bit 7.
20722    pub const ENABLE_LEGACY_DITHERING: Self = Self(128u32);
20723    ///Bit 2.
20724    pub const FRAGMENT_REGION: Self = Self(4u32);
20725    ///Bit 3.
20726    pub const CUSTOM_RESOLVE: Self = Self(8u32);
20727}
20728impl core::ops::BitOr for SubpassDescriptionFlagBits {
20729    type Output = Self;
20730    #[inline]
20731    fn bitor(self, rhs: Self) -> Self {
20732        Self(self.0 | rhs.0)
20733    }
20734}
20735impl core::ops::BitOrAssign for SubpassDescriptionFlagBits {
20736    #[inline]
20737    fn bitor_assign(&mut self, rhs: Self) {
20738        self.0 |= rhs.0;
20739    }
20740}
20741impl core::ops::BitAnd for SubpassDescriptionFlagBits {
20742    type Output = Self;
20743    #[inline]
20744    fn bitand(self, rhs: Self) -> Self {
20745        Self(self.0 & rhs.0)
20746    }
20747}
20748impl core::ops::BitAndAssign for SubpassDescriptionFlagBits {
20749    #[inline]
20750    fn bitand_assign(&mut self, rhs: Self) {
20751        self.0 &= rhs.0;
20752    }
20753}
20754impl core::ops::BitXor for SubpassDescriptionFlagBits {
20755    type Output = Self;
20756    #[inline]
20757    fn bitxor(self, rhs: Self) -> Self {
20758        Self(self.0 ^ rhs.0)
20759    }
20760}
20761impl core::ops::BitXorAssign for SubpassDescriptionFlagBits {
20762    #[inline]
20763    fn bitxor_assign(&mut self, rhs: Self) {
20764        self.0 ^= rhs.0;
20765    }
20766}
20767impl core::ops::Not for SubpassDescriptionFlagBits {
20768    type Output = Self;
20769    #[inline]
20770    fn not(self) -> Self {
20771        Self(!self.0)
20772    }
20773}
20774impl core::fmt::Debug for SubpassDescriptionFlagBits {
20775    #[allow(unused_mut, unused_variables)]
20776    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20777        let mut first = true;
20778        let mut remaining = self.0;
20779        if remaining & Self::PER_VIEW_ATTRIBUTES_BIT.0 != 0 {
20780            if !first {
20781                f.write_str(" | ")?;
20782            }
20783            f.write_str("PER_VIEW_ATTRIBUTES_BIT")?;
20784            remaining &= !Self::PER_VIEW_ATTRIBUTES_BIT.0;
20785            first = false;
20786        }
20787        if remaining & Self::PER_VIEW_POSITION_X_ONLY_BIT.0 != 0 {
20788            if !first {
20789                f.write_str(" | ")?;
20790            }
20791            f.write_str("PER_VIEW_POSITION_X_ONLY_BIT")?;
20792            remaining &= !Self::PER_VIEW_POSITION_X_ONLY_BIT.0;
20793            first = false;
20794        }
20795        if remaining & Self::TILE_SHADING_APRON_BIT.0 != 0 {
20796            if !first {
20797                f.write_str(" | ")?;
20798            }
20799            f.write_str("TILE_SHADING_APRON_BIT")?;
20800            remaining &= !Self::TILE_SHADING_APRON_BIT.0;
20801            first = false;
20802        }
20803        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS.0 != 0 {
20804            if !first {
20805                f.write_str(" | ")?;
20806            }
20807            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS")?;
20808            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS.0;
20809            first = false;
20810        }
20811        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS.0 != 0 {
20812            if !first {
20813                f.write_str(" | ")?;
20814            }
20815            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS")?;
20816            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS.0;
20817            first = false;
20818        }
20819        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS.0 != 0 {
20820            if !first {
20821                f.write_str(" | ")?;
20822            }
20823            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS")?;
20824            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS.0;
20825            first = false;
20826        }
20827        if remaining & Self::ENABLE_LEGACY_DITHERING.0 != 0 {
20828            if !first {
20829                f.write_str(" | ")?;
20830            }
20831            f.write_str("ENABLE_LEGACY_DITHERING")?;
20832            remaining &= !Self::ENABLE_LEGACY_DITHERING.0;
20833            first = false;
20834        }
20835        if remaining & Self::FRAGMENT_REGION.0 != 0 {
20836            if !first {
20837                f.write_str(" | ")?;
20838            }
20839            f.write_str("FRAGMENT_REGION")?;
20840            remaining &= !Self::FRAGMENT_REGION.0;
20841            first = false;
20842        }
20843        if remaining & Self::CUSTOM_RESOLVE.0 != 0 {
20844            if !first {
20845                f.write_str(" | ")?;
20846            }
20847            f.write_str("CUSTOM_RESOLVE")?;
20848            remaining &= !Self::CUSTOM_RESOLVE.0;
20849            first = false;
20850        }
20851        if remaining != 0u32 {
20852            if !first {
20853                f.write_str(" | ")?;
20854            }
20855            write!(f, "{:#x}", remaining)?;
20856        } else if first {
20857            f.write_str("(empty)")?;
20858        }
20859        Ok(())
20860    }
20861}
20862///[`VkSurfaceCounterFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCounterFlagBitsEXT.html)
20863#[repr(transparent)]
20864#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
20865#[doc(alias = "VkSurfaceCounterFlagBitsEXT")]
20866pub struct SurfaceCounterFlagBitsEXT(u32);
20867impl SurfaceCounterFlagBitsEXT {
20868    #[inline]
20869    pub const fn empty() -> Self {
20870        Self(0u32)
20871    }
20872    #[inline]
20873    pub const fn from_raw(value: u32) -> Self {
20874        Self(value)
20875    }
20876    #[inline]
20877    pub const fn as_raw(self) -> u32 {
20878        self.0
20879    }
20880    #[inline]
20881    pub const fn is_empty(self) -> bool {
20882        self.0 == 0u32
20883    }
20884    #[inline]
20885    pub const fn contains(self, other: Self) -> bool {
20886        (self.0 & other.0) == other.0
20887    }
20888    #[inline]
20889    pub const fn all() -> Self {
20890        Self(1u32)
20891    }
20892    ///Bit 0.
20893    pub const VBLANK: Self = Self(1u32);
20894}
20895impl core::ops::BitOr for SurfaceCounterFlagBitsEXT {
20896    type Output = Self;
20897    #[inline]
20898    fn bitor(self, rhs: Self) -> Self {
20899        Self(self.0 | rhs.0)
20900    }
20901}
20902impl core::ops::BitOrAssign for SurfaceCounterFlagBitsEXT {
20903    #[inline]
20904    fn bitor_assign(&mut self, rhs: Self) {
20905        self.0 |= rhs.0;
20906    }
20907}
20908impl core::ops::BitAnd for SurfaceCounterFlagBitsEXT {
20909    type Output = Self;
20910    #[inline]
20911    fn bitand(self, rhs: Self) -> Self {
20912        Self(self.0 & rhs.0)
20913    }
20914}
20915impl core::ops::BitAndAssign for SurfaceCounterFlagBitsEXT {
20916    #[inline]
20917    fn bitand_assign(&mut self, rhs: Self) {
20918        self.0 &= rhs.0;
20919    }
20920}
20921impl core::ops::BitXor for SurfaceCounterFlagBitsEXT {
20922    type Output = Self;
20923    #[inline]
20924    fn bitxor(self, rhs: Self) -> Self {
20925        Self(self.0 ^ rhs.0)
20926    }
20927}
20928impl core::ops::BitXorAssign for SurfaceCounterFlagBitsEXT {
20929    #[inline]
20930    fn bitxor_assign(&mut self, rhs: Self) {
20931        self.0 ^= rhs.0;
20932    }
20933}
20934impl core::ops::Not for SurfaceCounterFlagBitsEXT {
20935    type Output = Self;
20936    #[inline]
20937    fn not(self) -> Self {
20938        Self(!self.0)
20939    }
20940}
20941impl core::fmt::Debug for SurfaceCounterFlagBitsEXT {
20942    #[allow(unused_mut, unused_variables)]
20943    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20944        let mut first = true;
20945        let mut remaining = self.0;
20946        if remaining & Self::VBLANK.0 != 0 {
20947            if !first {
20948                f.write_str(" | ")?;
20949            }
20950            f.write_str("VBLANK")?;
20951            remaining &= !Self::VBLANK.0;
20952            first = false;
20953        }
20954        if remaining != 0u32 {
20955            if !first {
20956                f.write_str(" | ")?;
20957            }
20958            write!(f, "{:#x}", remaining)?;
20959        } else if first {
20960            f.write_str("(empty)")?;
20961        }
20962        Ok(())
20963    }
20964}
20965///[`VkSurfaceTransformFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceTransformFlagBitsKHR.html)
20966#[repr(transparent)]
20967#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
20968#[doc(alias = "VkSurfaceTransformFlagBitsKHR")]
20969pub struct SurfaceTransformFlagBitsKHR(u32);
20970impl SurfaceTransformFlagBitsKHR {
20971    #[inline]
20972    pub const fn empty() -> Self {
20973        Self(0u32)
20974    }
20975    #[inline]
20976    pub const fn from_raw(value: u32) -> Self {
20977        Self(value)
20978    }
20979    #[inline]
20980    pub const fn as_raw(self) -> u32 {
20981        self.0
20982    }
20983    #[inline]
20984    pub const fn is_empty(self) -> bool {
20985        self.0 == 0u32
20986    }
20987    #[inline]
20988    pub const fn contains(self, other: Self) -> bool {
20989        (self.0 & other.0) == other.0
20990    }
20991    #[inline]
20992    pub const fn all() -> Self {
20993        Self(511u32)
20994    }
20995    ///Bit 0.
20996    pub const IDENTITY: Self = Self(1u32);
20997    ///Bit 1.
20998    pub const ROTATE_90: Self = Self(2u32);
20999    ///Bit 2.
21000    pub const ROTATE_180: Self = Self(4u32);
21001    ///Bit 3.
21002    pub const ROTATE_270: Self = Self(8u32);
21003    ///Bit 4.
21004    pub const HORIZONTAL_MIRROR: Self = Self(16u32);
21005    ///Bit 5.
21006    pub const HORIZONTAL_MIRROR_ROTATE_90: Self = Self(32u32);
21007    ///Bit 6.
21008    pub const HORIZONTAL_MIRROR_ROTATE_180: Self = Self(64u32);
21009    ///Bit 7.
21010    pub const HORIZONTAL_MIRROR_ROTATE_270: Self = Self(128u32);
21011    ///Bit 8.
21012    pub const INHERIT: Self = Self(256u32);
21013}
21014impl core::ops::BitOr for SurfaceTransformFlagBitsKHR {
21015    type Output = Self;
21016    #[inline]
21017    fn bitor(self, rhs: Self) -> Self {
21018        Self(self.0 | rhs.0)
21019    }
21020}
21021impl core::ops::BitOrAssign for SurfaceTransformFlagBitsKHR {
21022    #[inline]
21023    fn bitor_assign(&mut self, rhs: Self) {
21024        self.0 |= rhs.0;
21025    }
21026}
21027impl core::ops::BitAnd for SurfaceTransformFlagBitsKHR {
21028    type Output = Self;
21029    #[inline]
21030    fn bitand(self, rhs: Self) -> Self {
21031        Self(self.0 & rhs.0)
21032    }
21033}
21034impl core::ops::BitAndAssign for SurfaceTransformFlagBitsKHR {
21035    #[inline]
21036    fn bitand_assign(&mut self, rhs: Self) {
21037        self.0 &= rhs.0;
21038    }
21039}
21040impl core::ops::BitXor for SurfaceTransformFlagBitsKHR {
21041    type Output = Self;
21042    #[inline]
21043    fn bitxor(self, rhs: Self) -> Self {
21044        Self(self.0 ^ rhs.0)
21045    }
21046}
21047impl core::ops::BitXorAssign for SurfaceTransformFlagBitsKHR {
21048    #[inline]
21049    fn bitxor_assign(&mut self, rhs: Self) {
21050        self.0 ^= rhs.0;
21051    }
21052}
21053impl core::ops::Not for SurfaceTransformFlagBitsKHR {
21054    type Output = Self;
21055    #[inline]
21056    fn not(self) -> Self {
21057        Self(!self.0)
21058    }
21059}
21060impl core::fmt::Debug for SurfaceTransformFlagBitsKHR {
21061    #[allow(unused_mut, unused_variables)]
21062    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21063        let mut first = true;
21064        let mut remaining = self.0;
21065        if remaining & Self::IDENTITY.0 != 0 {
21066            if !first {
21067                f.write_str(" | ")?;
21068            }
21069            f.write_str("IDENTITY")?;
21070            remaining &= !Self::IDENTITY.0;
21071            first = false;
21072        }
21073        if remaining & Self::ROTATE_90.0 != 0 {
21074            if !first {
21075                f.write_str(" | ")?;
21076            }
21077            f.write_str("ROTATE_90")?;
21078            remaining &= !Self::ROTATE_90.0;
21079            first = false;
21080        }
21081        if remaining & Self::ROTATE_180.0 != 0 {
21082            if !first {
21083                f.write_str(" | ")?;
21084            }
21085            f.write_str("ROTATE_180")?;
21086            remaining &= !Self::ROTATE_180.0;
21087            first = false;
21088        }
21089        if remaining & Self::ROTATE_270.0 != 0 {
21090            if !first {
21091                f.write_str(" | ")?;
21092            }
21093            f.write_str("ROTATE_270")?;
21094            remaining &= !Self::ROTATE_270.0;
21095            first = false;
21096        }
21097        if remaining & Self::HORIZONTAL_MIRROR.0 != 0 {
21098            if !first {
21099                f.write_str(" | ")?;
21100            }
21101            f.write_str("HORIZONTAL_MIRROR")?;
21102            remaining &= !Self::HORIZONTAL_MIRROR.0;
21103            first = false;
21104        }
21105        if remaining & Self::HORIZONTAL_MIRROR_ROTATE_90.0 != 0 {
21106            if !first {
21107                f.write_str(" | ")?;
21108            }
21109            f.write_str("HORIZONTAL_MIRROR_ROTATE_90")?;
21110            remaining &= !Self::HORIZONTAL_MIRROR_ROTATE_90.0;
21111            first = false;
21112        }
21113        if remaining & Self::HORIZONTAL_MIRROR_ROTATE_180.0 != 0 {
21114            if !first {
21115                f.write_str(" | ")?;
21116            }
21117            f.write_str("HORIZONTAL_MIRROR_ROTATE_180")?;
21118            remaining &= !Self::HORIZONTAL_MIRROR_ROTATE_180.0;
21119            first = false;
21120        }
21121        if remaining & Self::HORIZONTAL_MIRROR_ROTATE_270.0 != 0 {
21122            if !first {
21123                f.write_str(" | ")?;
21124            }
21125            f.write_str("HORIZONTAL_MIRROR_ROTATE_270")?;
21126            remaining &= !Self::HORIZONTAL_MIRROR_ROTATE_270.0;
21127            first = false;
21128        }
21129        if remaining & Self::INHERIT.0 != 0 {
21130            if !first {
21131                f.write_str(" | ")?;
21132            }
21133            f.write_str("INHERIT")?;
21134            remaining &= !Self::INHERIT.0;
21135            first = false;
21136        }
21137        if remaining != 0u32 {
21138            if !first {
21139                f.write_str(" | ")?;
21140            }
21141            write!(f, "{:#x}", remaining)?;
21142        } else if first {
21143            f.write_str("(empty)")?;
21144        }
21145        Ok(())
21146    }
21147}
21148///[`VkSwapchainCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCreateFlagBitsKHR.html)
21149#[repr(transparent)]
21150#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
21151#[doc(alias = "VkSwapchainCreateFlagBitsKHR")]
21152pub struct SwapchainCreateFlagBitsKHR(u32);
21153impl SwapchainCreateFlagBitsKHR {
21154    #[inline]
21155    pub const fn empty() -> Self {
21156        Self(0u32)
21157    }
21158    #[inline]
21159    pub const fn from_raw(value: u32) -> Self {
21160        Self(value)
21161    }
21162    #[inline]
21163    pub const fn as_raw(self) -> u32 {
21164        self.0
21165    }
21166    #[inline]
21167    pub const fn is_empty(self) -> bool {
21168        self.0 == 0u32
21169    }
21170    #[inline]
21171    pub const fn contains(self, other: Self) -> bool {
21172        (self.0 & other.0) == other.0
21173    }
21174    #[inline]
21175    pub const fn all() -> Self {
21176        Self(711u32)
21177    }
21178    ///Bit 0.
21179    pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(1u32);
21180    ///Bit 1.
21181    pub const PROTECTED: Self = Self(2u32);
21182    ///Bit 2.
21183    pub const MUTABLE_FORMAT: Self = Self(4u32);
21184    ///Bit 9.
21185    pub const PRESENT_TIMING: Self = Self(512u32);
21186    ///Bit 6.
21187    pub const PRESENT_ID_2: Self = Self(64u32);
21188    ///Bit 7.
21189    pub const PRESENT_WAIT_2: Self = Self(128u32);
21190}
21191impl core::ops::BitOr for SwapchainCreateFlagBitsKHR {
21192    type Output = Self;
21193    #[inline]
21194    fn bitor(self, rhs: Self) -> Self {
21195        Self(self.0 | rhs.0)
21196    }
21197}
21198impl core::ops::BitOrAssign for SwapchainCreateFlagBitsKHR {
21199    #[inline]
21200    fn bitor_assign(&mut self, rhs: Self) {
21201        self.0 |= rhs.0;
21202    }
21203}
21204impl core::ops::BitAnd for SwapchainCreateFlagBitsKHR {
21205    type Output = Self;
21206    #[inline]
21207    fn bitand(self, rhs: Self) -> Self {
21208        Self(self.0 & rhs.0)
21209    }
21210}
21211impl core::ops::BitAndAssign for SwapchainCreateFlagBitsKHR {
21212    #[inline]
21213    fn bitand_assign(&mut self, rhs: Self) {
21214        self.0 &= rhs.0;
21215    }
21216}
21217impl core::ops::BitXor for SwapchainCreateFlagBitsKHR {
21218    type Output = Self;
21219    #[inline]
21220    fn bitxor(self, rhs: Self) -> Self {
21221        Self(self.0 ^ rhs.0)
21222    }
21223}
21224impl core::ops::BitXorAssign for SwapchainCreateFlagBitsKHR {
21225    #[inline]
21226    fn bitxor_assign(&mut self, rhs: Self) {
21227        self.0 ^= rhs.0;
21228    }
21229}
21230impl core::ops::Not for SwapchainCreateFlagBitsKHR {
21231    type Output = Self;
21232    #[inline]
21233    fn not(self) -> Self {
21234        Self(!self.0)
21235    }
21236}
21237impl core::fmt::Debug for SwapchainCreateFlagBitsKHR {
21238    #[allow(unused_mut, unused_variables)]
21239    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21240        let mut first = true;
21241        let mut remaining = self.0;
21242        if remaining & Self::SPLIT_INSTANCE_BIND_REGIONS.0 != 0 {
21243            if !first {
21244                f.write_str(" | ")?;
21245            }
21246            f.write_str("SPLIT_INSTANCE_BIND_REGIONS")?;
21247            remaining &= !Self::SPLIT_INSTANCE_BIND_REGIONS.0;
21248            first = false;
21249        }
21250        if remaining & Self::PROTECTED.0 != 0 {
21251            if !first {
21252                f.write_str(" | ")?;
21253            }
21254            f.write_str("PROTECTED")?;
21255            remaining &= !Self::PROTECTED.0;
21256            first = false;
21257        }
21258        if remaining & Self::MUTABLE_FORMAT.0 != 0 {
21259            if !first {
21260                f.write_str(" | ")?;
21261            }
21262            f.write_str("MUTABLE_FORMAT")?;
21263            remaining &= !Self::MUTABLE_FORMAT.0;
21264            first = false;
21265        }
21266        if remaining & Self::PRESENT_TIMING.0 != 0 {
21267            if !first {
21268                f.write_str(" | ")?;
21269            }
21270            f.write_str("PRESENT_TIMING")?;
21271            remaining &= !Self::PRESENT_TIMING.0;
21272            first = false;
21273        }
21274        if remaining & Self::PRESENT_ID_2.0 != 0 {
21275            if !first {
21276                f.write_str(" | ")?;
21277            }
21278            f.write_str("PRESENT_ID_2")?;
21279            remaining &= !Self::PRESENT_ID_2.0;
21280            first = false;
21281        }
21282        if remaining & Self::PRESENT_WAIT_2.0 != 0 {
21283            if !first {
21284                f.write_str(" | ")?;
21285            }
21286            f.write_str("PRESENT_WAIT_2")?;
21287            remaining &= !Self::PRESENT_WAIT_2.0;
21288            first = false;
21289        }
21290        if remaining != 0u32 {
21291            if !first {
21292                f.write_str(" | ")?;
21293            }
21294            write!(f, "{:#x}", remaining)?;
21295        } else if first {
21296            f.write_str("(empty)")?;
21297        }
21298        Ok(())
21299    }
21300}
21301///[`VkSwapchainImageUsageFlagBitsANDROID`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainImageUsageFlagBitsANDROID.html)
21302#[repr(transparent)]
21303#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
21304#[doc(alias = "VkSwapchainImageUsageFlagBitsANDROID")]
21305pub struct SwapchainImageUsageFlagBitsANDROID(u32);
21306impl SwapchainImageUsageFlagBitsANDROID {
21307    #[inline]
21308    pub const fn empty() -> Self {
21309        Self(0u32)
21310    }
21311    #[inline]
21312    pub const fn from_raw(value: u32) -> Self {
21313        Self(value)
21314    }
21315    #[inline]
21316    pub const fn as_raw(self) -> u32 {
21317        self.0
21318    }
21319    #[inline]
21320    pub const fn is_empty(self) -> bool {
21321        self.0 == 0u32
21322    }
21323    #[inline]
21324    pub const fn contains(self, other: Self) -> bool {
21325        (self.0 & other.0) == other.0
21326    }
21327    #[inline]
21328    pub const fn all() -> Self {
21329        Self(1u32)
21330    }
21331    ///Bit 0.
21332    pub const SHARED_BIT: Self = Self(1u32);
21333}
21334impl core::ops::BitOr for SwapchainImageUsageFlagBitsANDROID {
21335    type Output = Self;
21336    #[inline]
21337    fn bitor(self, rhs: Self) -> Self {
21338        Self(self.0 | rhs.0)
21339    }
21340}
21341impl core::ops::BitOrAssign for SwapchainImageUsageFlagBitsANDROID {
21342    #[inline]
21343    fn bitor_assign(&mut self, rhs: Self) {
21344        self.0 |= rhs.0;
21345    }
21346}
21347impl core::ops::BitAnd for SwapchainImageUsageFlagBitsANDROID {
21348    type Output = Self;
21349    #[inline]
21350    fn bitand(self, rhs: Self) -> Self {
21351        Self(self.0 & rhs.0)
21352    }
21353}
21354impl core::ops::BitAndAssign for SwapchainImageUsageFlagBitsANDROID {
21355    #[inline]
21356    fn bitand_assign(&mut self, rhs: Self) {
21357        self.0 &= rhs.0;
21358    }
21359}
21360impl core::ops::BitXor for SwapchainImageUsageFlagBitsANDROID {
21361    type Output = Self;
21362    #[inline]
21363    fn bitxor(self, rhs: Self) -> Self {
21364        Self(self.0 ^ rhs.0)
21365    }
21366}
21367impl core::ops::BitXorAssign for SwapchainImageUsageFlagBitsANDROID {
21368    #[inline]
21369    fn bitxor_assign(&mut self, rhs: Self) {
21370        self.0 ^= rhs.0;
21371    }
21372}
21373impl core::ops::Not for SwapchainImageUsageFlagBitsANDROID {
21374    type Output = Self;
21375    #[inline]
21376    fn not(self) -> Self {
21377        Self(!self.0)
21378    }
21379}
21380impl core::fmt::Debug for SwapchainImageUsageFlagBitsANDROID {
21381    #[allow(unused_mut, unused_variables)]
21382    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21383        let mut first = true;
21384        let mut remaining = self.0;
21385        if remaining & Self::SHARED_BIT.0 != 0 {
21386            if !first {
21387                f.write_str(" | ")?;
21388            }
21389            f.write_str("SHARED_BIT")?;
21390            remaining &= !Self::SHARED_BIT.0;
21391            first = false;
21392        }
21393        if remaining != 0u32 {
21394            if !first {
21395                f.write_str(" | ")?;
21396            }
21397            write!(f, "{:#x}", remaining)?;
21398        } else if first {
21399            f.write_str("(empty)")?;
21400        }
21401        Ok(())
21402    }
21403}
21404///[`VkSwapchainImageUsageFlagBitsOHOS`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainImageUsageFlagBitsOHOS.html)
21405#[repr(transparent)]
21406#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
21407#[doc(alias = "VkSwapchainImageUsageFlagBitsOHOS")]
21408pub struct SwapchainImageUsageFlagBitsOHOS(u32);
21409impl SwapchainImageUsageFlagBitsOHOS {
21410    #[inline]
21411    pub const fn empty() -> Self {
21412        Self(0u32)
21413    }
21414    #[inline]
21415    pub const fn from_raw(value: u32) -> Self {
21416        Self(value)
21417    }
21418    #[inline]
21419    pub const fn as_raw(self) -> u32 {
21420        self.0
21421    }
21422    #[inline]
21423    pub const fn is_empty(self) -> bool {
21424        self.0 == 0u32
21425    }
21426    #[inline]
21427    pub const fn contains(self, other: Self) -> bool {
21428        (self.0 & other.0) == other.0
21429    }
21430    #[inline]
21431    pub const fn all() -> Self {
21432        Self(1u32)
21433    }
21434    ///Bit 0.
21435    pub const SHARED_BIT: Self = Self(1u32);
21436}
21437impl core::ops::BitOr for SwapchainImageUsageFlagBitsOHOS {
21438    type Output = Self;
21439    #[inline]
21440    fn bitor(self, rhs: Self) -> Self {
21441        Self(self.0 | rhs.0)
21442    }
21443}
21444impl core::ops::BitOrAssign for SwapchainImageUsageFlagBitsOHOS {
21445    #[inline]
21446    fn bitor_assign(&mut self, rhs: Self) {
21447        self.0 |= rhs.0;
21448    }
21449}
21450impl core::ops::BitAnd for SwapchainImageUsageFlagBitsOHOS {
21451    type Output = Self;
21452    #[inline]
21453    fn bitand(self, rhs: Self) -> Self {
21454        Self(self.0 & rhs.0)
21455    }
21456}
21457impl core::ops::BitAndAssign for SwapchainImageUsageFlagBitsOHOS {
21458    #[inline]
21459    fn bitand_assign(&mut self, rhs: Self) {
21460        self.0 &= rhs.0;
21461    }
21462}
21463impl core::ops::BitXor for SwapchainImageUsageFlagBitsOHOS {
21464    type Output = Self;
21465    #[inline]
21466    fn bitxor(self, rhs: Self) -> Self {
21467        Self(self.0 ^ rhs.0)
21468    }
21469}
21470impl core::ops::BitXorAssign for SwapchainImageUsageFlagBitsOHOS {
21471    #[inline]
21472    fn bitxor_assign(&mut self, rhs: Self) {
21473        self.0 ^= rhs.0;
21474    }
21475}
21476impl core::ops::Not for SwapchainImageUsageFlagBitsOHOS {
21477    type Output = Self;
21478    #[inline]
21479    fn not(self) -> Self {
21480        Self(!self.0)
21481    }
21482}
21483impl core::fmt::Debug for SwapchainImageUsageFlagBitsOHOS {
21484    #[allow(unused_mut, unused_variables)]
21485    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21486        let mut first = true;
21487        let mut remaining = self.0;
21488        if remaining & Self::SHARED_BIT.0 != 0 {
21489            if !first {
21490                f.write_str(" | ")?;
21491            }
21492            f.write_str("SHARED_BIT")?;
21493            remaining &= !Self::SHARED_BIT.0;
21494            first = false;
21495        }
21496        if remaining != 0u32 {
21497            if !first {
21498                f.write_str(" | ")?;
21499            }
21500            write!(f, "{:#x}", remaining)?;
21501        } else if first {
21502            f.write_str("(empty)")?;
21503        }
21504        Ok(())
21505    }
21506}
21507///[`VkTensorCreateFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCreateFlagBitsARM.html)
21508#[repr(transparent)]
21509#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
21510#[doc(alias = "VkTensorCreateFlagBitsARM")]
21511pub struct TensorCreateFlagBitsARM(u64);
21512impl TensorCreateFlagBitsARM {
21513    #[inline]
21514    pub const fn empty() -> Self {
21515        Self(0u64)
21516    }
21517    #[inline]
21518    pub const fn from_raw(value: u64) -> Self {
21519        Self(value)
21520    }
21521    #[inline]
21522    pub const fn as_raw(self) -> u64 {
21523        self.0
21524    }
21525    #[inline]
21526    pub const fn is_empty(self) -> bool {
21527        self.0 == 0u64
21528    }
21529    #[inline]
21530    pub const fn contains(self, other: Self) -> bool {
21531        (self.0 & other.0) == other.0
21532    }
21533    #[inline]
21534    pub const fn all() -> Self {
21535        Self(15u64)
21536    }
21537    ///Bit 0.
21538    pub const MUTABLE_FORMAT_BIT: Self = Self(1u64);
21539    ///Bit 1.
21540    pub const PROTECTED_BIT: Self = Self(2u64);
21541    ///Bit 3.
21542    pub const DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT: Self = Self(8u64);
21543    ///Bit 2.
21544    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT: Self = Self(4u64);
21545}
21546impl core::ops::BitOr for TensorCreateFlagBitsARM {
21547    type Output = Self;
21548    #[inline]
21549    fn bitor(self, rhs: Self) -> Self {
21550        Self(self.0 | rhs.0)
21551    }
21552}
21553impl core::ops::BitOrAssign for TensorCreateFlagBitsARM {
21554    #[inline]
21555    fn bitor_assign(&mut self, rhs: Self) {
21556        self.0 |= rhs.0;
21557    }
21558}
21559impl core::ops::BitAnd for TensorCreateFlagBitsARM {
21560    type Output = Self;
21561    #[inline]
21562    fn bitand(self, rhs: Self) -> Self {
21563        Self(self.0 & rhs.0)
21564    }
21565}
21566impl core::ops::BitAndAssign for TensorCreateFlagBitsARM {
21567    #[inline]
21568    fn bitand_assign(&mut self, rhs: Self) {
21569        self.0 &= rhs.0;
21570    }
21571}
21572impl core::ops::BitXor for TensorCreateFlagBitsARM {
21573    type Output = Self;
21574    #[inline]
21575    fn bitxor(self, rhs: Self) -> Self {
21576        Self(self.0 ^ rhs.0)
21577    }
21578}
21579impl core::ops::BitXorAssign for TensorCreateFlagBitsARM {
21580    #[inline]
21581    fn bitxor_assign(&mut self, rhs: Self) {
21582        self.0 ^= rhs.0;
21583    }
21584}
21585impl core::ops::Not for TensorCreateFlagBitsARM {
21586    type Output = Self;
21587    #[inline]
21588    fn not(self) -> Self {
21589        Self(!self.0)
21590    }
21591}
21592impl core::fmt::Debug for TensorCreateFlagBitsARM {
21593    #[allow(unused_mut, unused_variables)]
21594    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21595        let mut first = true;
21596        let mut remaining = self.0;
21597        if remaining & Self::MUTABLE_FORMAT_BIT.0 != 0 {
21598            if !first {
21599                f.write_str(" | ")?;
21600            }
21601            f.write_str("MUTABLE_FORMAT_BIT")?;
21602            remaining &= !Self::MUTABLE_FORMAT_BIT.0;
21603            first = false;
21604        }
21605        if remaining & Self::PROTECTED_BIT.0 != 0 {
21606            if !first {
21607                f.write_str(" | ")?;
21608            }
21609            f.write_str("PROTECTED_BIT")?;
21610            remaining &= !Self::PROTECTED_BIT.0;
21611            first = false;
21612        }
21613        if remaining & Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT.0 != 0 {
21614            if !first {
21615                f.write_str(" | ")?;
21616            }
21617            f.write_str("DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT")?;
21618            remaining &= !Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT.0;
21619            first = false;
21620        }
21621        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT.0 != 0 {
21622            if !first {
21623                f.write_str(" | ")?;
21624            }
21625            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT")?;
21626            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT.0;
21627            first = false;
21628        }
21629        if remaining != 0u64 {
21630            if !first {
21631                f.write_str(" | ")?;
21632            }
21633            write!(f, "{:#x}", remaining)?;
21634        } else if first {
21635            f.write_str("(empty)")?;
21636        }
21637        Ok(())
21638    }
21639}
21640///[`VkTensorUsageFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorUsageFlagBitsARM.html)
21641#[repr(transparent)]
21642#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
21643#[doc(alias = "VkTensorUsageFlagBitsARM")]
21644pub struct TensorUsageFlagBitsARM(u64);
21645impl TensorUsageFlagBitsARM {
21646    #[inline]
21647    pub const fn empty() -> Self {
21648        Self(0u64)
21649    }
21650    #[inline]
21651    pub const fn from_raw(value: u64) -> Self {
21652        Self(value)
21653    }
21654    #[inline]
21655    pub const fn as_raw(self) -> u64 {
21656        self.0
21657    }
21658    #[inline]
21659    pub const fn is_empty(self) -> bool {
21660        self.0 == 0u64
21661    }
21662    #[inline]
21663    pub const fn contains(self, other: Self) -> bool {
21664        (self.0 & other.0) == other.0
21665    }
21666    #[inline]
21667    pub const fn all() -> Self {
21668        Self(62u64)
21669    }
21670    ///Bit 1.
21671    pub const SHADER_BIT: Self = Self(2u64);
21672    ///Bit 2.
21673    pub const TRANSFER_SRC_BIT: Self = Self(4u64);
21674    ///Bit 3.
21675    pub const TRANSFER_DST_BIT: Self = Self(8u64);
21676    ///Bit 4.
21677    pub const IMAGE_ALIASING_BIT: Self = Self(16u64);
21678    ///Bit 5.
21679    pub const DATA_GRAPH_BIT: Self = Self(32u64);
21680}
21681impl core::ops::BitOr for TensorUsageFlagBitsARM {
21682    type Output = Self;
21683    #[inline]
21684    fn bitor(self, rhs: Self) -> Self {
21685        Self(self.0 | rhs.0)
21686    }
21687}
21688impl core::ops::BitOrAssign for TensorUsageFlagBitsARM {
21689    #[inline]
21690    fn bitor_assign(&mut self, rhs: Self) {
21691        self.0 |= rhs.0;
21692    }
21693}
21694impl core::ops::BitAnd for TensorUsageFlagBitsARM {
21695    type Output = Self;
21696    #[inline]
21697    fn bitand(self, rhs: Self) -> Self {
21698        Self(self.0 & rhs.0)
21699    }
21700}
21701impl core::ops::BitAndAssign for TensorUsageFlagBitsARM {
21702    #[inline]
21703    fn bitand_assign(&mut self, rhs: Self) {
21704        self.0 &= rhs.0;
21705    }
21706}
21707impl core::ops::BitXor for TensorUsageFlagBitsARM {
21708    type Output = Self;
21709    #[inline]
21710    fn bitxor(self, rhs: Self) -> Self {
21711        Self(self.0 ^ rhs.0)
21712    }
21713}
21714impl core::ops::BitXorAssign for TensorUsageFlagBitsARM {
21715    #[inline]
21716    fn bitxor_assign(&mut self, rhs: Self) {
21717        self.0 ^= rhs.0;
21718    }
21719}
21720impl core::ops::Not for TensorUsageFlagBitsARM {
21721    type Output = Self;
21722    #[inline]
21723    fn not(self) -> Self {
21724        Self(!self.0)
21725    }
21726}
21727impl core::fmt::Debug for TensorUsageFlagBitsARM {
21728    #[allow(unused_mut, unused_variables)]
21729    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21730        let mut first = true;
21731        let mut remaining = self.0;
21732        if remaining & Self::SHADER_BIT.0 != 0 {
21733            if !first {
21734                f.write_str(" | ")?;
21735            }
21736            f.write_str("SHADER_BIT")?;
21737            remaining &= !Self::SHADER_BIT.0;
21738            first = false;
21739        }
21740        if remaining & Self::TRANSFER_SRC_BIT.0 != 0 {
21741            if !first {
21742                f.write_str(" | ")?;
21743            }
21744            f.write_str("TRANSFER_SRC_BIT")?;
21745            remaining &= !Self::TRANSFER_SRC_BIT.0;
21746            first = false;
21747        }
21748        if remaining & Self::TRANSFER_DST_BIT.0 != 0 {
21749            if !first {
21750                f.write_str(" | ")?;
21751            }
21752            f.write_str("TRANSFER_DST_BIT")?;
21753            remaining &= !Self::TRANSFER_DST_BIT.0;
21754            first = false;
21755        }
21756        if remaining & Self::IMAGE_ALIASING_BIT.0 != 0 {
21757            if !first {
21758                f.write_str(" | ")?;
21759            }
21760            f.write_str("IMAGE_ALIASING_BIT")?;
21761            remaining &= !Self::IMAGE_ALIASING_BIT.0;
21762            first = false;
21763        }
21764        if remaining & Self::DATA_GRAPH_BIT.0 != 0 {
21765            if !first {
21766                f.write_str(" | ")?;
21767            }
21768            f.write_str("DATA_GRAPH_BIT")?;
21769            remaining &= !Self::DATA_GRAPH_BIT.0;
21770            first = false;
21771        }
21772        if remaining != 0u64 {
21773            if !first {
21774                f.write_str(" | ")?;
21775            }
21776            write!(f, "{:#x}", remaining)?;
21777        } else if first {
21778            f.write_str("(empty)")?;
21779        }
21780        Ok(())
21781    }
21782}
21783///[`VkTensorViewCreateFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagBitsARM.html)
21784#[repr(transparent)]
21785#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
21786#[doc(alias = "VkTensorViewCreateFlagBitsARM")]
21787pub struct TensorViewCreateFlagBitsARM(u64);
21788impl TensorViewCreateFlagBitsARM {
21789    #[inline]
21790    pub const fn empty() -> Self {
21791        Self(0u64)
21792    }
21793    #[inline]
21794    pub const fn from_raw(value: u64) -> Self {
21795        Self(value)
21796    }
21797    #[inline]
21798    pub const fn as_raw(self) -> u64 {
21799        self.0
21800    }
21801    #[inline]
21802    pub const fn is_empty(self) -> bool {
21803        self.0 == 0u64
21804    }
21805    #[inline]
21806    pub const fn contains(self, other: Self) -> bool {
21807        (self.0 & other.0) == other.0
21808    }
21809    #[inline]
21810    pub const fn all() -> Self {
21811        Self(1u64)
21812    }
21813    ///Bit 0.
21814    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT: Self = Self(1u64);
21815}
21816impl core::ops::BitOr for TensorViewCreateFlagBitsARM {
21817    type Output = Self;
21818    #[inline]
21819    fn bitor(self, rhs: Self) -> Self {
21820        Self(self.0 | rhs.0)
21821    }
21822}
21823impl core::ops::BitOrAssign for TensorViewCreateFlagBitsARM {
21824    #[inline]
21825    fn bitor_assign(&mut self, rhs: Self) {
21826        self.0 |= rhs.0;
21827    }
21828}
21829impl core::ops::BitAnd for TensorViewCreateFlagBitsARM {
21830    type Output = Self;
21831    #[inline]
21832    fn bitand(self, rhs: Self) -> Self {
21833        Self(self.0 & rhs.0)
21834    }
21835}
21836impl core::ops::BitAndAssign for TensorViewCreateFlagBitsARM {
21837    #[inline]
21838    fn bitand_assign(&mut self, rhs: Self) {
21839        self.0 &= rhs.0;
21840    }
21841}
21842impl core::ops::BitXor for TensorViewCreateFlagBitsARM {
21843    type Output = Self;
21844    #[inline]
21845    fn bitxor(self, rhs: Self) -> Self {
21846        Self(self.0 ^ rhs.0)
21847    }
21848}
21849impl core::ops::BitXorAssign for TensorViewCreateFlagBitsARM {
21850    #[inline]
21851    fn bitxor_assign(&mut self, rhs: Self) {
21852        self.0 ^= rhs.0;
21853    }
21854}
21855impl core::ops::Not for TensorViewCreateFlagBitsARM {
21856    type Output = Self;
21857    #[inline]
21858    fn not(self) -> Self {
21859        Self(!self.0)
21860    }
21861}
21862impl core::fmt::Debug for TensorViewCreateFlagBitsARM {
21863    #[allow(unused_mut, unused_variables)]
21864    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21865        let mut first = true;
21866        let mut remaining = self.0;
21867        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT.0 != 0 {
21868            if !first {
21869                f.write_str(" | ")?;
21870            }
21871            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT")?;
21872            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT.0;
21873            first = false;
21874        }
21875        if remaining != 0u64 {
21876            if !first {
21877                f.write_str(" | ")?;
21878            }
21879            write!(f, "{:#x}", remaining)?;
21880        } else if first {
21881            f.write_str("(empty)")?;
21882        }
21883        Ok(())
21884    }
21885}
21886///[`VkTileShadingRenderPassFlagBitsQCOM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagBitsQCOM.html)
21887#[repr(transparent)]
21888#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
21889#[doc(alias = "VkTileShadingRenderPassFlagBitsQCOM")]
21890pub struct TileShadingRenderPassFlagBitsQCOM(u32);
21891impl TileShadingRenderPassFlagBitsQCOM {
21892    #[inline]
21893    pub const fn empty() -> Self {
21894        Self(0u32)
21895    }
21896    #[inline]
21897    pub const fn from_raw(value: u32) -> Self {
21898        Self(value)
21899    }
21900    #[inline]
21901    pub const fn as_raw(self) -> u32 {
21902        self.0
21903    }
21904    #[inline]
21905    pub const fn is_empty(self) -> bool {
21906        self.0 == 0u32
21907    }
21908    #[inline]
21909    pub const fn contains(self, other: Self) -> bool {
21910        (self.0 & other.0) == other.0
21911    }
21912    #[inline]
21913    pub const fn all() -> Self {
21914        Self(3u32)
21915    }
21916    ///Bit 0.
21917    pub const ENABLE_BIT: Self = Self(1u32);
21918    ///Bit 1.
21919    pub const PER_TILE_EXECUTION_BIT: Self = Self(2u32);
21920}
21921impl core::ops::BitOr for TileShadingRenderPassFlagBitsQCOM {
21922    type Output = Self;
21923    #[inline]
21924    fn bitor(self, rhs: Self) -> Self {
21925        Self(self.0 | rhs.0)
21926    }
21927}
21928impl core::ops::BitOrAssign for TileShadingRenderPassFlagBitsQCOM {
21929    #[inline]
21930    fn bitor_assign(&mut self, rhs: Self) {
21931        self.0 |= rhs.0;
21932    }
21933}
21934impl core::ops::BitAnd for TileShadingRenderPassFlagBitsQCOM {
21935    type Output = Self;
21936    #[inline]
21937    fn bitand(self, rhs: Self) -> Self {
21938        Self(self.0 & rhs.0)
21939    }
21940}
21941impl core::ops::BitAndAssign for TileShadingRenderPassFlagBitsQCOM {
21942    #[inline]
21943    fn bitand_assign(&mut self, rhs: Self) {
21944        self.0 &= rhs.0;
21945    }
21946}
21947impl core::ops::BitXor for TileShadingRenderPassFlagBitsQCOM {
21948    type Output = Self;
21949    #[inline]
21950    fn bitxor(self, rhs: Self) -> Self {
21951        Self(self.0 ^ rhs.0)
21952    }
21953}
21954impl core::ops::BitXorAssign for TileShadingRenderPassFlagBitsQCOM {
21955    #[inline]
21956    fn bitxor_assign(&mut self, rhs: Self) {
21957        self.0 ^= rhs.0;
21958    }
21959}
21960impl core::ops::Not for TileShadingRenderPassFlagBitsQCOM {
21961    type Output = Self;
21962    #[inline]
21963    fn not(self) -> Self {
21964        Self(!self.0)
21965    }
21966}
21967impl core::fmt::Debug for TileShadingRenderPassFlagBitsQCOM {
21968    #[allow(unused_mut, unused_variables)]
21969    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21970        let mut first = true;
21971        let mut remaining = self.0;
21972        if remaining & Self::ENABLE_BIT.0 != 0 {
21973            if !first {
21974                f.write_str(" | ")?;
21975            }
21976            f.write_str("ENABLE_BIT")?;
21977            remaining &= !Self::ENABLE_BIT.0;
21978            first = false;
21979        }
21980        if remaining & Self::PER_TILE_EXECUTION_BIT.0 != 0 {
21981            if !first {
21982                f.write_str(" | ")?;
21983            }
21984            f.write_str("PER_TILE_EXECUTION_BIT")?;
21985            remaining &= !Self::PER_TILE_EXECUTION_BIT.0;
21986            first = false;
21987        }
21988        if remaining != 0u32 {
21989            if !first {
21990                f.write_str(" | ")?;
21991            }
21992            write!(f, "{:#x}", remaining)?;
21993        } else if first {
21994            f.write_str("(empty)")?;
21995        }
21996        Ok(())
21997    }
21998}
21999///[`VkToolPurposeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkToolPurposeFlagBits.html)
22000#[repr(transparent)]
22001#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22002#[doc(alias = "VkToolPurposeFlagBits")]
22003pub struct ToolPurposeFlagBits(u32);
22004impl ToolPurposeFlagBits {
22005    #[inline]
22006    pub const fn empty() -> Self {
22007        Self(0u32)
22008    }
22009    #[inline]
22010    pub const fn from_raw(value: u32) -> Self {
22011        Self(value)
22012    }
22013    #[inline]
22014    pub const fn as_raw(self) -> u32 {
22015        self.0
22016    }
22017    #[inline]
22018    pub const fn is_empty(self) -> bool {
22019        self.0 == 0u32
22020    }
22021    #[inline]
22022    pub const fn contains(self, other: Self) -> bool {
22023        (self.0 & other.0) == other.0
22024    }
22025    #[inline]
22026    pub const fn all() -> Self {
22027        Self(127u32)
22028    }
22029    ///Bit 0.
22030    pub const VALIDATION: Self = Self(1u32);
22031    ///Bit 1.
22032    pub const PROFILING: Self = Self(2u32);
22033    ///Bit 2.
22034    pub const TRACING: Self = Self(4u32);
22035    ///Bit 3.
22036    pub const ADDITIONAL_FEATURES: Self = Self(8u32);
22037    ///Bit 4.
22038    pub const MODIFYING_FEATURES: Self = Self(16u32);
22039    ///Bit 5.
22040    pub const DEBUG_REPORTING: Self = Self(32u32);
22041    ///Bit 6.
22042    pub const DEBUG_MARKERS: Self = Self(64u32);
22043}
22044impl core::ops::BitOr for ToolPurposeFlagBits {
22045    type Output = Self;
22046    #[inline]
22047    fn bitor(self, rhs: Self) -> Self {
22048        Self(self.0 | rhs.0)
22049    }
22050}
22051impl core::ops::BitOrAssign for ToolPurposeFlagBits {
22052    #[inline]
22053    fn bitor_assign(&mut self, rhs: Self) {
22054        self.0 |= rhs.0;
22055    }
22056}
22057impl core::ops::BitAnd for ToolPurposeFlagBits {
22058    type Output = Self;
22059    #[inline]
22060    fn bitand(self, rhs: Self) -> Self {
22061        Self(self.0 & rhs.0)
22062    }
22063}
22064impl core::ops::BitAndAssign for ToolPurposeFlagBits {
22065    #[inline]
22066    fn bitand_assign(&mut self, rhs: Self) {
22067        self.0 &= rhs.0;
22068    }
22069}
22070impl core::ops::BitXor for ToolPurposeFlagBits {
22071    type Output = Self;
22072    #[inline]
22073    fn bitxor(self, rhs: Self) -> Self {
22074        Self(self.0 ^ rhs.0)
22075    }
22076}
22077impl core::ops::BitXorAssign for ToolPurposeFlagBits {
22078    #[inline]
22079    fn bitxor_assign(&mut self, rhs: Self) {
22080        self.0 ^= rhs.0;
22081    }
22082}
22083impl core::ops::Not for ToolPurposeFlagBits {
22084    type Output = Self;
22085    #[inline]
22086    fn not(self) -> Self {
22087        Self(!self.0)
22088    }
22089}
22090impl core::fmt::Debug for ToolPurposeFlagBits {
22091    #[allow(unused_mut, unused_variables)]
22092    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22093        let mut first = true;
22094        let mut remaining = self.0;
22095        if remaining & Self::VALIDATION.0 != 0 {
22096            if !first {
22097                f.write_str(" | ")?;
22098            }
22099            f.write_str("VALIDATION")?;
22100            remaining &= !Self::VALIDATION.0;
22101            first = false;
22102        }
22103        if remaining & Self::PROFILING.0 != 0 {
22104            if !first {
22105                f.write_str(" | ")?;
22106            }
22107            f.write_str("PROFILING")?;
22108            remaining &= !Self::PROFILING.0;
22109            first = false;
22110        }
22111        if remaining & Self::TRACING.0 != 0 {
22112            if !first {
22113                f.write_str(" | ")?;
22114            }
22115            f.write_str("TRACING")?;
22116            remaining &= !Self::TRACING.0;
22117            first = false;
22118        }
22119        if remaining & Self::ADDITIONAL_FEATURES.0 != 0 {
22120            if !first {
22121                f.write_str(" | ")?;
22122            }
22123            f.write_str("ADDITIONAL_FEATURES")?;
22124            remaining &= !Self::ADDITIONAL_FEATURES.0;
22125            first = false;
22126        }
22127        if remaining & Self::MODIFYING_FEATURES.0 != 0 {
22128            if !first {
22129                f.write_str(" | ")?;
22130            }
22131            f.write_str("MODIFYING_FEATURES")?;
22132            remaining &= !Self::MODIFYING_FEATURES.0;
22133            first = false;
22134        }
22135        if remaining & Self::DEBUG_REPORTING.0 != 0 {
22136            if !first {
22137                f.write_str(" | ")?;
22138            }
22139            f.write_str("DEBUG_REPORTING")?;
22140            remaining &= !Self::DEBUG_REPORTING.0;
22141            first = false;
22142        }
22143        if remaining & Self::DEBUG_MARKERS.0 != 0 {
22144            if !first {
22145                f.write_str(" | ")?;
22146            }
22147            f.write_str("DEBUG_MARKERS")?;
22148            remaining &= !Self::DEBUG_MARKERS.0;
22149            first = false;
22150        }
22151        if remaining != 0u32 {
22152            if !first {
22153                f.write_str(" | ")?;
22154            }
22155            write!(f, "{:#x}", remaining)?;
22156        } else if first {
22157            f.write_str("(empty)")?;
22158        }
22159        Ok(())
22160    }
22161}
22162///[`VkVideoCapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCapabilityFlagBitsKHR.html)
22163#[repr(transparent)]
22164#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22165#[doc(alias = "VkVideoCapabilityFlagBitsKHR")]
22166pub struct VideoCapabilityFlagBitsKHR(u32);
22167impl VideoCapabilityFlagBitsKHR {
22168    #[inline]
22169    pub const fn empty() -> Self {
22170        Self(0u32)
22171    }
22172    #[inline]
22173    pub const fn from_raw(value: u32) -> Self {
22174        Self(value)
22175    }
22176    #[inline]
22177    pub const fn as_raw(self) -> u32 {
22178        self.0
22179    }
22180    #[inline]
22181    pub const fn is_empty(self) -> bool {
22182        self.0 == 0u32
22183    }
22184    #[inline]
22185    pub const fn contains(self, other: Self) -> bool {
22186        (self.0 & other.0) == other.0
22187    }
22188    #[inline]
22189    pub const fn all() -> Self {
22190        Self(3u32)
22191    }
22192    ///Bit 0.
22193    pub const PROTECTED_CONTENT: Self = Self(1u32);
22194    ///Bit 1.
22195    pub const SEPARATE_REFERENCE_IMAGES: Self = Self(2u32);
22196}
22197impl core::ops::BitOr for VideoCapabilityFlagBitsKHR {
22198    type Output = Self;
22199    #[inline]
22200    fn bitor(self, rhs: Self) -> Self {
22201        Self(self.0 | rhs.0)
22202    }
22203}
22204impl core::ops::BitOrAssign for VideoCapabilityFlagBitsKHR {
22205    #[inline]
22206    fn bitor_assign(&mut self, rhs: Self) {
22207        self.0 |= rhs.0;
22208    }
22209}
22210impl core::ops::BitAnd for VideoCapabilityFlagBitsKHR {
22211    type Output = Self;
22212    #[inline]
22213    fn bitand(self, rhs: Self) -> Self {
22214        Self(self.0 & rhs.0)
22215    }
22216}
22217impl core::ops::BitAndAssign for VideoCapabilityFlagBitsKHR {
22218    #[inline]
22219    fn bitand_assign(&mut self, rhs: Self) {
22220        self.0 &= rhs.0;
22221    }
22222}
22223impl core::ops::BitXor for VideoCapabilityFlagBitsKHR {
22224    type Output = Self;
22225    #[inline]
22226    fn bitxor(self, rhs: Self) -> Self {
22227        Self(self.0 ^ rhs.0)
22228    }
22229}
22230impl core::ops::BitXorAssign for VideoCapabilityFlagBitsKHR {
22231    #[inline]
22232    fn bitxor_assign(&mut self, rhs: Self) {
22233        self.0 ^= rhs.0;
22234    }
22235}
22236impl core::ops::Not for VideoCapabilityFlagBitsKHR {
22237    type Output = Self;
22238    #[inline]
22239    fn not(self) -> Self {
22240        Self(!self.0)
22241    }
22242}
22243impl core::fmt::Debug for VideoCapabilityFlagBitsKHR {
22244    #[allow(unused_mut, unused_variables)]
22245    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22246        let mut first = true;
22247        let mut remaining = self.0;
22248        if remaining & Self::PROTECTED_CONTENT.0 != 0 {
22249            if !first {
22250                f.write_str(" | ")?;
22251            }
22252            f.write_str("PROTECTED_CONTENT")?;
22253            remaining &= !Self::PROTECTED_CONTENT.0;
22254            first = false;
22255        }
22256        if remaining & Self::SEPARATE_REFERENCE_IMAGES.0 != 0 {
22257            if !first {
22258                f.write_str(" | ")?;
22259            }
22260            f.write_str("SEPARATE_REFERENCE_IMAGES")?;
22261            remaining &= !Self::SEPARATE_REFERENCE_IMAGES.0;
22262            first = false;
22263        }
22264        if remaining != 0u32 {
22265            if !first {
22266                f.write_str(" | ")?;
22267            }
22268            write!(f, "{:#x}", remaining)?;
22269        } else if first {
22270            f.write_str("(empty)")?;
22271        }
22272        Ok(())
22273    }
22274}
22275///[`VkVideoChromaSubsamplingFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html)
22276#[repr(transparent)]
22277#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22278#[doc(alias = "VkVideoChromaSubsamplingFlagBitsKHR")]
22279pub struct VideoChromaSubsamplingFlagBitsKHR(u32);
22280impl VideoChromaSubsamplingFlagBitsKHR {
22281    #[inline]
22282    pub const fn empty() -> Self {
22283        Self(0u32)
22284    }
22285    #[inline]
22286    pub const fn from_raw(value: u32) -> Self {
22287        Self(value)
22288    }
22289    #[inline]
22290    pub const fn as_raw(self) -> u32 {
22291        self.0
22292    }
22293    #[inline]
22294    pub const fn is_empty(self) -> bool {
22295        self.0 == 0u32
22296    }
22297    #[inline]
22298    pub const fn contains(self, other: Self) -> bool {
22299        (self.0 & other.0) == other.0
22300    }
22301    #[inline]
22302    pub const fn all() -> Self {
22303        Self(15u32)
22304    }
22305    pub const INVALID: Self = Self(0u32);
22306    ///Bit 0.
22307    pub const MONOCHROME: Self = Self(1u32);
22308    ///Bit 1.
22309    pub const _420: Self = Self(2u32);
22310    ///Bit 2.
22311    pub const _422: Self = Self(4u32);
22312    ///Bit 3.
22313    pub const _444: Self = Self(8u32);
22314}
22315impl core::ops::BitOr for VideoChromaSubsamplingFlagBitsKHR {
22316    type Output = Self;
22317    #[inline]
22318    fn bitor(self, rhs: Self) -> Self {
22319        Self(self.0 | rhs.0)
22320    }
22321}
22322impl core::ops::BitOrAssign for VideoChromaSubsamplingFlagBitsKHR {
22323    #[inline]
22324    fn bitor_assign(&mut self, rhs: Self) {
22325        self.0 |= rhs.0;
22326    }
22327}
22328impl core::ops::BitAnd for VideoChromaSubsamplingFlagBitsKHR {
22329    type Output = Self;
22330    #[inline]
22331    fn bitand(self, rhs: Self) -> Self {
22332        Self(self.0 & rhs.0)
22333    }
22334}
22335impl core::ops::BitAndAssign for VideoChromaSubsamplingFlagBitsKHR {
22336    #[inline]
22337    fn bitand_assign(&mut self, rhs: Self) {
22338        self.0 &= rhs.0;
22339    }
22340}
22341impl core::ops::BitXor for VideoChromaSubsamplingFlagBitsKHR {
22342    type Output = Self;
22343    #[inline]
22344    fn bitxor(self, rhs: Self) -> Self {
22345        Self(self.0 ^ rhs.0)
22346    }
22347}
22348impl core::ops::BitXorAssign for VideoChromaSubsamplingFlagBitsKHR {
22349    #[inline]
22350    fn bitxor_assign(&mut self, rhs: Self) {
22351        self.0 ^= rhs.0;
22352    }
22353}
22354impl core::ops::Not for VideoChromaSubsamplingFlagBitsKHR {
22355    type Output = Self;
22356    #[inline]
22357    fn not(self) -> Self {
22358        Self(!self.0)
22359    }
22360}
22361impl core::fmt::Debug for VideoChromaSubsamplingFlagBitsKHR {
22362    #[allow(unused_mut, unused_variables)]
22363    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22364        let mut first = true;
22365        let mut remaining = self.0;
22366        if remaining & Self::MONOCHROME.0 != 0 {
22367            if !first {
22368                f.write_str(" | ")?;
22369            }
22370            f.write_str("MONOCHROME")?;
22371            remaining &= !Self::MONOCHROME.0;
22372            first = false;
22373        }
22374        if remaining & Self::_420.0 != 0 {
22375            if !first {
22376                f.write_str(" | ")?;
22377            }
22378            f.write_str("_420")?;
22379            remaining &= !Self::_420.0;
22380            first = false;
22381        }
22382        if remaining & Self::_422.0 != 0 {
22383            if !first {
22384                f.write_str(" | ")?;
22385            }
22386            f.write_str("_422")?;
22387            remaining &= !Self::_422.0;
22388            first = false;
22389        }
22390        if remaining & Self::_444.0 != 0 {
22391            if !first {
22392                f.write_str(" | ")?;
22393            }
22394            f.write_str("_444")?;
22395            remaining &= !Self::_444.0;
22396            first = false;
22397        }
22398        if remaining != 0u32 {
22399            if !first {
22400                f.write_str(" | ")?;
22401            }
22402            write!(f, "{:#x}", remaining)?;
22403        } else if first {
22404            f.write_str("(empty)")?;
22405        }
22406        Ok(())
22407    }
22408}
22409///[`VkVideoCodecOperationFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodecOperationFlagBitsKHR.html)
22410#[repr(transparent)]
22411#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22412#[doc(alias = "VkVideoCodecOperationFlagBitsKHR")]
22413pub struct VideoCodecOperationFlagBitsKHR(u32);
22414impl VideoCodecOperationFlagBitsKHR {
22415    #[inline]
22416    pub const fn empty() -> Self {
22417        Self(0u32)
22418    }
22419    #[inline]
22420    pub const fn from_raw(value: u32) -> Self {
22421        Self(value)
22422    }
22423    #[inline]
22424    pub const fn as_raw(self) -> u32 {
22425        self.0
22426    }
22427    #[inline]
22428    pub const fn is_empty(self) -> bool {
22429        self.0 == 0u32
22430    }
22431    #[inline]
22432    pub const fn contains(self, other: Self) -> bool {
22433        (self.0 & other.0) == other.0
22434    }
22435    #[inline]
22436    pub const fn all() -> Self {
22437        Self(458767u32)
22438    }
22439    pub const NONE: Self = Self(0u32);
22440    ///Bit 16.
22441    pub const ENCODE_H264: Self = Self(65536u32);
22442    ///Bit 17.
22443    pub const ENCODE_H265: Self = Self(131072u32);
22444    ///Bit 0.
22445    pub const DECODE_H264: Self = Self(1u32);
22446    ///Bit 1.
22447    pub const DECODE_H265: Self = Self(2u32);
22448    ///Bit 2.
22449    pub const DECODE_AV1: Self = Self(4u32);
22450    ///Bit 18.
22451    pub const ENCODE_AV1: Self = Self(262144u32);
22452    ///Bit 3.
22453    pub const DECODE_VP9: Self = Self(8u32);
22454}
22455impl core::ops::BitOr for VideoCodecOperationFlagBitsKHR {
22456    type Output = Self;
22457    #[inline]
22458    fn bitor(self, rhs: Self) -> Self {
22459        Self(self.0 | rhs.0)
22460    }
22461}
22462impl core::ops::BitOrAssign for VideoCodecOperationFlagBitsKHR {
22463    #[inline]
22464    fn bitor_assign(&mut self, rhs: Self) {
22465        self.0 |= rhs.0;
22466    }
22467}
22468impl core::ops::BitAnd for VideoCodecOperationFlagBitsKHR {
22469    type Output = Self;
22470    #[inline]
22471    fn bitand(self, rhs: Self) -> Self {
22472        Self(self.0 & rhs.0)
22473    }
22474}
22475impl core::ops::BitAndAssign for VideoCodecOperationFlagBitsKHR {
22476    #[inline]
22477    fn bitand_assign(&mut self, rhs: Self) {
22478        self.0 &= rhs.0;
22479    }
22480}
22481impl core::ops::BitXor for VideoCodecOperationFlagBitsKHR {
22482    type Output = Self;
22483    #[inline]
22484    fn bitxor(self, rhs: Self) -> Self {
22485        Self(self.0 ^ rhs.0)
22486    }
22487}
22488impl core::ops::BitXorAssign for VideoCodecOperationFlagBitsKHR {
22489    #[inline]
22490    fn bitxor_assign(&mut self, rhs: Self) {
22491        self.0 ^= rhs.0;
22492    }
22493}
22494impl core::ops::Not for VideoCodecOperationFlagBitsKHR {
22495    type Output = Self;
22496    #[inline]
22497    fn not(self) -> Self {
22498        Self(!self.0)
22499    }
22500}
22501impl core::fmt::Debug for VideoCodecOperationFlagBitsKHR {
22502    #[allow(unused_mut, unused_variables)]
22503    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22504        let mut first = true;
22505        let mut remaining = self.0;
22506        if remaining & Self::ENCODE_H264.0 != 0 {
22507            if !first {
22508                f.write_str(" | ")?;
22509            }
22510            f.write_str("ENCODE_H264")?;
22511            remaining &= !Self::ENCODE_H264.0;
22512            first = false;
22513        }
22514        if remaining & Self::ENCODE_H265.0 != 0 {
22515            if !first {
22516                f.write_str(" | ")?;
22517            }
22518            f.write_str("ENCODE_H265")?;
22519            remaining &= !Self::ENCODE_H265.0;
22520            first = false;
22521        }
22522        if remaining & Self::DECODE_H264.0 != 0 {
22523            if !first {
22524                f.write_str(" | ")?;
22525            }
22526            f.write_str("DECODE_H264")?;
22527            remaining &= !Self::DECODE_H264.0;
22528            first = false;
22529        }
22530        if remaining & Self::DECODE_H265.0 != 0 {
22531            if !first {
22532                f.write_str(" | ")?;
22533            }
22534            f.write_str("DECODE_H265")?;
22535            remaining &= !Self::DECODE_H265.0;
22536            first = false;
22537        }
22538        if remaining & Self::DECODE_AV1.0 != 0 {
22539            if !first {
22540                f.write_str(" | ")?;
22541            }
22542            f.write_str("DECODE_AV1")?;
22543            remaining &= !Self::DECODE_AV1.0;
22544            first = false;
22545        }
22546        if remaining & Self::ENCODE_AV1.0 != 0 {
22547            if !first {
22548                f.write_str(" | ")?;
22549            }
22550            f.write_str("ENCODE_AV1")?;
22551            remaining &= !Self::ENCODE_AV1.0;
22552            first = false;
22553        }
22554        if remaining & Self::DECODE_VP9.0 != 0 {
22555            if !first {
22556                f.write_str(" | ")?;
22557            }
22558            f.write_str("DECODE_VP9")?;
22559            remaining &= !Self::DECODE_VP9.0;
22560            first = false;
22561        }
22562        if remaining != 0u32 {
22563            if !first {
22564                f.write_str(" | ")?;
22565            }
22566            write!(f, "{:#x}", remaining)?;
22567        } else if first {
22568            f.write_str("(empty)")?;
22569        }
22570        Ok(())
22571    }
22572}
22573///[`VkVideoCodingControlFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodingControlFlagBitsKHR.html)
22574#[repr(transparent)]
22575#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22576#[doc(alias = "VkVideoCodingControlFlagBitsKHR")]
22577pub struct VideoCodingControlFlagBitsKHR(u32);
22578impl VideoCodingControlFlagBitsKHR {
22579    #[inline]
22580    pub const fn empty() -> Self {
22581        Self(0u32)
22582    }
22583    #[inline]
22584    pub const fn from_raw(value: u32) -> Self {
22585        Self(value)
22586    }
22587    #[inline]
22588    pub const fn as_raw(self) -> u32 {
22589        self.0
22590    }
22591    #[inline]
22592    pub const fn is_empty(self) -> bool {
22593        self.0 == 0u32
22594    }
22595    #[inline]
22596    pub const fn contains(self, other: Self) -> bool {
22597        (self.0 & other.0) == other.0
22598    }
22599    #[inline]
22600    pub const fn all() -> Self {
22601        Self(7u32)
22602    }
22603    ///Bit 0.
22604    pub const RESET: Self = Self(1u32);
22605    ///Bit 1.
22606    pub const ENCODE_RATE_CONTROL: Self = Self(2u32);
22607    ///Bit 2.
22608    pub const ENCODE_QUALITY_LEVEL: Self = Self(4u32);
22609}
22610impl core::ops::BitOr for VideoCodingControlFlagBitsKHR {
22611    type Output = Self;
22612    #[inline]
22613    fn bitor(self, rhs: Self) -> Self {
22614        Self(self.0 | rhs.0)
22615    }
22616}
22617impl core::ops::BitOrAssign for VideoCodingControlFlagBitsKHR {
22618    #[inline]
22619    fn bitor_assign(&mut self, rhs: Self) {
22620        self.0 |= rhs.0;
22621    }
22622}
22623impl core::ops::BitAnd for VideoCodingControlFlagBitsKHR {
22624    type Output = Self;
22625    #[inline]
22626    fn bitand(self, rhs: Self) -> Self {
22627        Self(self.0 & rhs.0)
22628    }
22629}
22630impl core::ops::BitAndAssign for VideoCodingControlFlagBitsKHR {
22631    #[inline]
22632    fn bitand_assign(&mut self, rhs: Self) {
22633        self.0 &= rhs.0;
22634    }
22635}
22636impl core::ops::BitXor for VideoCodingControlFlagBitsKHR {
22637    type Output = Self;
22638    #[inline]
22639    fn bitxor(self, rhs: Self) -> Self {
22640        Self(self.0 ^ rhs.0)
22641    }
22642}
22643impl core::ops::BitXorAssign for VideoCodingControlFlagBitsKHR {
22644    #[inline]
22645    fn bitxor_assign(&mut self, rhs: Self) {
22646        self.0 ^= rhs.0;
22647    }
22648}
22649impl core::ops::Not for VideoCodingControlFlagBitsKHR {
22650    type Output = Self;
22651    #[inline]
22652    fn not(self) -> Self {
22653        Self(!self.0)
22654    }
22655}
22656impl core::fmt::Debug for VideoCodingControlFlagBitsKHR {
22657    #[allow(unused_mut, unused_variables)]
22658    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22659        let mut first = true;
22660        let mut remaining = self.0;
22661        if remaining & Self::RESET.0 != 0 {
22662            if !first {
22663                f.write_str(" | ")?;
22664            }
22665            f.write_str("RESET")?;
22666            remaining &= !Self::RESET.0;
22667            first = false;
22668        }
22669        if remaining & Self::ENCODE_RATE_CONTROL.0 != 0 {
22670            if !first {
22671                f.write_str(" | ")?;
22672            }
22673            f.write_str("ENCODE_RATE_CONTROL")?;
22674            remaining &= !Self::ENCODE_RATE_CONTROL.0;
22675            first = false;
22676        }
22677        if remaining & Self::ENCODE_QUALITY_LEVEL.0 != 0 {
22678            if !first {
22679                f.write_str(" | ")?;
22680            }
22681            f.write_str("ENCODE_QUALITY_LEVEL")?;
22682            remaining &= !Self::ENCODE_QUALITY_LEVEL.0;
22683            first = false;
22684        }
22685        if remaining != 0u32 {
22686            if !first {
22687                f.write_str(" | ")?;
22688            }
22689            write!(f, "{:#x}", remaining)?;
22690        } else if first {
22691            f.write_str("(empty)")?;
22692        }
22693        Ok(())
22694    }
22695}
22696///[`VkVideoComponentBitDepthFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoComponentBitDepthFlagBitsKHR.html)
22697#[repr(transparent)]
22698#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22699#[doc(alias = "VkVideoComponentBitDepthFlagBitsKHR")]
22700pub struct VideoComponentBitDepthFlagBitsKHR(u32);
22701impl VideoComponentBitDepthFlagBitsKHR {
22702    #[inline]
22703    pub const fn empty() -> Self {
22704        Self(0u32)
22705    }
22706    #[inline]
22707    pub const fn from_raw(value: u32) -> Self {
22708        Self(value)
22709    }
22710    #[inline]
22711    pub const fn as_raw(self) -> u32 {
22712        self.0
22713    }
22714    #[inline]
22715    pub const fn is_empty(self) -> bool {
22716        self.0 == 0u32
22717    }
22718    #[inline]
22719    pub const fn contains(self, other: Self) -> bool {
22720        (self.0 & other.0) == other.0
22721    }
22722    #[inline]
22723    pub const fn all() -> Self {
22724        Self(21u32)
22725    }
22726    pub const INVALID: Self = Self(0u32);
22727    ///Bit 0.
22728    pub const _8: Self = Self(1u32);
22729    ///Bit 2.
22730    pub const _10: Self = Self(4u32);
22731    ///Bit 4.
22732    pub const _12: Self = Self(16u32);
22733}
22734impl core::ops::BitOr for VideoComponentBitDepthFlagBitsKHR {
22735    type Output = Self;
22736    #[inline]
22737    fn bitor(self, rhs: Self) -> Self {
22738        Self(self.0 | rhs.0)
22739    }
22740}
22741impl core::ops::BitOrAssign for VideoComponentBitDepthFlagBitsKHR {
22742    #[inline]
22743    fn bitor_assign(&mut self, rhs: Self) {
22744        self.0 |= rhs.0;
22745    }
22746}
22747impl core::ops::BitAnd for VideoComponentBitDepthFlagBitsKHR {
22748    type Output = Self;
22749    #[inline]
22750    fn bitand(self, rhs: Self) -> Self {
22751        Self(self.0 & rhs.0)
22752    }
22753}
22754impl core::ops::BitAndAssign for VideoComponentBitDepthFlagBitsKHR {
22755    #[inline]
22756    fn bitand_assign(&mut self, rhs: Self) {
22757        self.0 &= rhs.0;
22758    }
22759}
22760impl core::ops::BitXor for VideoComponentBitDepthFlagBitsKHR {
22761    type Output = Self;
22762    #[inline]
22763    fn bitxor(self, rhs: Self) -> Self {
22764        Self(self.0 ^ rhs.0)
22765    }
22766}
22767impl core::ops::BitXorAssign for VideoComponentBitDepthFlagBitsKHR {
22768    #[inline]
22769    fn bitxor_assign(&mut self, rhs: Self) {
22770        self.0 ^= rhs.0;
22771    }
22772}
22773impl core::ops::Not for VideoComponentBitDepthFlagBitsKHR {
22774    type Output = Self;
22775    #[inline]
22776    fn not(self) -> Self {
22777        Self(!self.0)
22778    }
22779}
22780impl core::fmt::Debug for VideoComponentBitDepthFlagBitsKHR {
22781    #[allow(unused_mut, unused_variables)]
22782    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22783        let mut first = true;
22784        let mut remaining = self.0;
22785        if remaining & Self::_8.0 != 0 {
22786            if !first {
22787                f.write_str(" | ")?;
22788            }
22789            f.write_str("_8")?;
22790            remaining &= !Self::_8.0;
22791            first = false;
22792        }
22793        if remaining & Self::_10.0 != 0 {
22794            if !first {
22795                f.write_str(" | ")?;
22796            }
22797            f.write_str("_10")?;
22798            remaining &= !Self::_10.0;
22799            first = false;
22800        }
22801        if remaining & Self::_12.0 != 0 {
22802            if !first {
22803                f.write_str(" | ")?;
22804            }
22805            f.write_str("_12")?;
22806            remaining &= !Self::_12.0;
22807            first = false;
22808        }
22809        if remaining != 0u32 {
22810            if !first {
22811                f.write_str(" | ")?;
22812            }
22813            write!(f, "{:#x}", remaining)?;
22814        } else if first {
22815            f.write_str("(empty)")?;
22816        }
22817        Ok(())
22818    }
22819}
22820///[`VkVideoDecodeCapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeCapabilityFlagBitsKHR.html)
22821#[repr(transparent)]
22822#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22823#[doc(alias = "VkVideoDecodeCapabilityFlagBitsKHR")]
22824pub struct VideoDecodeCapabilityFlagBitsKHR(u32);
22825impl VideoDecodeCapabilityFlagBitsKHR {
22826    #[inline]
22827    pub const fn empty() -> Self {
22828        Self(0u32)
22829    }
22830    #[inline]
22831    pub const fn from_raw(value: u32) -> Self {
22832        Self(value)
22833    }
22834    #[inline]
22835    pub const fn as_raw(self) -> u32 {
22836        self.0
22837    }
22838    #[inline]
22839    pub const fn is_empty(self) -> bool {
22840        self.0 == 0u32
22841    }
22842    #[inline]
22843    pub const fn contains(self, other: Self) -> bool {
22844        (self.0 & other.0) == other.0
22845    }
22846    #[inline]
22847    pub const fn all() -> Self {
22848        Self(3u32)
22849    }
22850    ///Bit 0.
22851    pub const DPB_AND_OUTPUT_COINCIDE: Self = Self(1u32);
22852    ///Bit 1.
22853    pub const DPB_AND_OUTPUT_DISTINCT: Self = Self(2u32);
22854}
22855impl core::ops::BitOr for VideoDecodeCapabilityFlagBitsKHR {
22856    type Output = Self;
22857    #[inline]
22858    fn bitor(self, rhs: Self) -> Self {
22859        Self(self.0 | rhs.0)
22860    }
22861}
22862impl core::ops::BitOrAssign for VideoDecodeCapabilityFlagBitsKHR {
22863    #[inline]
22864    fn bitor_assign(&mut self, rhs: Self) {
22865        self.0 |= rhs.0;
22866    }
22867}
22868impl core::ops::BitAnd for VideoDecodeCapabilityFlagBitsKHR {
22869    type Output = Self;
22870    #[inline]
22871    fn bitand(self, rhs: Self) -> Self {
22872        Self(self.0 & rhs.0)
22873    }
22874}
22875impl core::ops::BitAndAssign for VideoDecodeCapabilityFlagBitsKHR {
22876    #[inline]
22877    fn bitand_assign(&mut self, rhs: Self) {
22878        self.0 &= rhs.0;
22879    }
22880}
22881impl core::ops::BitXor for VideoDecodeCapabilityFlagBitsKHR {
22882    type Output = Self;
22883    #[inline]
22884    fn bitxor(self, rhs: Self) -> Self {
22885        Self(self.0 ^ rhs.0)
22886    }
22887}
22888impl core::ops::BitXorAssign for VideoDecodeCapabilityFlagBitsKHR {
22889    #[inline]
22890    fn bitxor_assign(&mut self, rhs: Self) {
22891        self.0 ^= rhs.0;
22892    }
22893}
22894impl core::ops::Not for VideoDecodeCapabilityFlagBitsKHR {
22895    type Output = Self;
22896    #[inline]
22897    fn not(self) -> Self {
22898        Self(!self.0)
22899    }
22900}
22901impl core::fmt::Debug for VideoDecodeCapabilityFlagBitsKHR {
22902    #[allow(unused_mut, unused_variables)]
22903    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22904        let mut first = true;
22905        let mut remaining = self.0;
22906        if remaining & Self::DPB_AND_OUTPUT_COINCIDE.0 != 0 {
22907            if !first {
22908                f.write_str(" | ")?;
22909            }
22910            f.write_str("DPB_AND_OUTPUT_COINCIDE")?;
22911            remaining &= !Self::DPB_AND_OUTPUT_COINCIDE.0;
22912            first = false;
22913        }
22914        if remaining & Self::DPB_AND_OUTPUT_DISTINCT.0 != 0 {
22915            if !first {
22916                f.write_str(" | ")?;
22917            }
22918            f.write_str("DPB_AND_OUTPUT_DISTINCT")?;
22919            remaining &= !Self::DPB_AND_OUTPUT_DISTINCT.0;
22920            first = false;
22921        }
22922        if remaining != 0u32 {
22923            if !first {
22924                f.write_str(" | ")?;
22925            }
22926            write!(f, "{:#x}", remaining)?;
22927        } else if first {
22928            f.write_str("(empty)")?;
22929        }
22930        Ok(())
22931    }
22932}
22933///[`VkVideoDecodeH264PictureLayoutFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureLayoutFlagBitsKHR.html)
22934#[repr(transparent)]
22935#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22936#[doc(alias = "VkVideoDecodeH264PictureLayoutFlagBitsKHR")]
22937pub struct VideoDecodeH264PictureLayoutFlagBitsKHR(u32);
22938impl VideoDecodeH264PictureLayoutFlagBitsKHR {
22939    #[inline]
22940    pub const fn empty() -> Self {
22941        Self(0u32)
22942    }
22943    #[inline]
22944    pub const fn from_raw(value: u32) -> Self {
22945        Self(value)
22946    }
22947    #[inline]
22948    pub const fn as_raw(self) -> u32 {
22949        self.0
22950    }
22951    #[inline]
22952    pub const fn is_empty(self) -> bool {
22953        self.0 == 0u32
22954    }
22955    #[inline]
22956    pub const fn contains(self, other: Self) -> bool {
22957        (self.0 & other.0) == other.0
22958    }
22959    #[inline]
22960    pub const fn all() -> Self {
22961        Self(3u32)
22962    }
22963    pub const PROGRESSIVE: Self = Self(0u32);
22964    ///Bit 0.
22965    pub const INTERLACED_INTERLEAVED_LINES: Self = Self(1u32);
22966    ///Bit 1.
22967    pub const INTERLACED_SEPARATE_PLANES: Self = Self(2u32);
22968}
22969impl core::ops::BitOr for VideoDecodeH264PictureLayoutFlagBitsKHR {
22970    type Output = Self;
22971    #[inline]
22972    fn bitor(self, rhs: Self) -> Self {
22973        Self(self.0 | rhs.0)
22974    }
22975}
22976impl core::ops::BitOrAssign for VideoDecodeH264PictureLayoutFlagBitsKHR {
22977    #[inline]
22978    fn bitor_assign(&mut self, rhs: Self) {
22979        self.0 |= rhs.0;
22980    }
22981}
22982impl core::ops::BitAnd for VideoDecodeH264PictureLayoutFlagBitsKHR {
22983    type Output = Self;
22984    #[inline]
22985    fn bitand(self, rhs: Self) -> Self {
22986        Self(self.0 & rhs.0)
22987    }
22988}
22989impl core::ops::BitAndAssign for VideoDecodeH264PictureLayoutFlagBitsKHR {
22990    #[inline]
22991    fn bitand_assign(&mut self, rhs: Self) {
22992        self.0 &= rhs.0;
22993    }
22994}
22995impl core::ops::BitXor for VideoDecodeH264PictureLayoutFlagBitsKHR {
22996    type Output = Self;
22997    #[inline]
22998    fn bitxor(self, rhs: Self) -> Self {
22999        Self(self.0 ^ rhs.0)
23000    }
23001}
23002impl core::ops::BitXorAssign for VideoDecodeH264PictureLayoutFlagBitsKHR {
23003    #[inline]
23004    fn bitxor_assign(&mut self, rhs: Self) {
23005        self.0 ^= rhs.0;
23006    }
23007}
23008impl core::ops::Not for VideoDecodeH264PictureLayoutFlagBitsKHR {
23009    type Output = Self;
23010    #[inline]
23011    fn not(self) -> Self {
23012        Self(!self.0)
23013    }
23014}
23015impl core::fmt::Debug for VideoDecodeH264PictureLayoutFlagBitsKHR {
23016    #[allow(unused_mut, unused_variables)]
23017    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23018        let mut first = true;
23019        let mut remaining = self.0;
23020        if remaining & Self::INTERLACED_INTERLEAVED_LINES.0 != 0 {
23021            if !first {
23022                f.write_str(" | ")?;
23023            }
23024            f.write_str("INTERLACED_INTERLEAVED_LINES")?;
23025            remaining &= !Self::INTERLACED_INTERLEAVED_LINES.0;
23026            first = false;
23027        }
23028        if remaining & Self::INTERLACED_SEPARATE_PLANES.0 != 0 {
23029            if !first {
23030                f.write_str(" | ")?;
23031            }
23032            f.write_str("INTERLACED_SEPARATE_PLANES")?;
23033            remaining &= !Self::INTERLACED_SEPARATE_PLANES.0;
23034            first = false;
23035        }
23036        if remaining != 0u32 {
23037            if !first {
23038                f.write_str(" | ")?;
23039            }
23040            write!(f, "{:#x}", remaining)?;
23041        } else if first {
23042            f.write_str("(empty)")?;
23043        }
23044        Ok(())
23045    }
23046}
23047///[`VkVideoDecodeUsageFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeUsageFlagBitsKHR.html)
23048#[repr(transparent)]
23049#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
23050#[doc(alias = "VkVideoDecodeUsageFlagBitsKHR")]
23051pub struct VideoDecodeUsageFlagBitsKHR(u32);
23052impl VideoDecodeUsageFlagBitsKHR {
23053    #[inline]
23054    pub const fn empty() -> Self {
23055        Self(0u32)
23056    }
23057    #[inline]
23058    pub const fn from_raw(value: u32) -> Self {
23059        Self(value)
23060    }
23061    #[inline]
23062    pub const fn as_raw(self) -> u32 {
23063        self.0
23064    }
23065    #[inline]
23066    pub const fn is_empty(self) -> bool {
23067        self.0 == 0u32
23068    }
23069    #[inline]
23070    pub const fn contains(self, other: Self) -> bool {
23071        (self.0 & other.0) == other.0
23072    }
23073    #[inline]
23074    pub const fn all() -> Self {
23075        Self(7u32)
23076    }
23077    pub const DEFAULT: Self = Self(0u32);
23078    ///Bit 0.
23079    pub const TRANSCODING: Self = Self(1u32);
23080    ///Bit 1.
23081    pub const OFFLINE: Self = Self(2u32);
23082    ///Bit 2.
23083    pub const STREAMING: Self = Self(4u32);
23084}
23085impl core::ops::BitOr for VideoDecodeUsageFlagBitsKHR {
23086    type Output = Self;
23087    #[inline]
23088    fn bitor(self, rhs: Self) -> Self {
23089        Self(self.0 | rhs.0)
23090    }
23091}
23092impl core::ops::BitOrAssign for VideoDecodeUsageFlagBitsKHR {
23093    #[inline]
23094    fn bitor_assign(&mut self, rhs: Self) {
23095        self.0 |= rhs.0;
23096    }
23097}
23098impl core::ops::BitAnd for VideoDecodeUsageFlagBitsKHR {
23099    type Output = Self;
23100    #[inline]
23101    fn bitand(self, rhs: Self) -> Self {
23102        Self(self.0 & rhs.0)
23103    }
23104}
23105impl core::ops::BitAndAssign for VideoDecodeUsageFlagBitsKHR {
23106    #[inline]
23107    fn bitand_assign(&mut self, rhs: Self) {
23108        self.0 &= rhs.0;
23109    }
23110}
23111impl core::ops::BitXor for VideoDecodeUsageFlagBitsKHR {
23112    type Output = Self;
23113    #[inline]
23114    fn bitxor(self, rhs: Self) -> Self {
23115        Self(self.0 ^ rhs.0)
23116    }
23117}
23118impl core::ops::BitXorAssign for VideoDecodeUsageFlagBitsKHR {
23119    #[inline]
23120    fn bitxor_assign(&mut self, rhs: Self) {
23121        self.0 ^= rhs.0;
23122    }
23123}
23124impl core::ops::Not for VideoDecodeUsageFlagBitsKHR {
23125    type Output = Self;
23126    #[inline]
23127    fn not(self) -> Self {
23128        Self(!self.0)
23129    }
23130}
23131impl core::fmt::Debug for VideoDecodeUsageFlagBitsKHR {
23132    #[allow(unused_mut, unused_variables)]
23133    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23134        let mut first = true;
23135        let mut remaining = self.0;
23136        if remaining & Self::TRANSCODING.0 != 0 {
23137            if !first {
23138                f.write_str(" | ")?;
23139            }
23140            f.write_str("TRANSCODING")?;
23141            remaining &= !Self::TRANSCODING.0;
23142            first = false;
23143        }
23144        if remaining & Self::OFFLINE.0 != 0 {
23145            if !first {
23146                f.write_str(" | ")?;
23147            }
23148            f.write_str("OFFLINE")?;
23149            remaining &= !Self::OFFLINE.0;
23150            first = false;
23151        }
23152        if remaining & Self::STREAMING.0 != 0 {
23153            if !first {
23154                f.write_str(" | ")?;
23155            }
23156            f.write_str("STREAMING")?;
23157            remaining &= !Self::STREAMING.0;
23158            first = false;
23159        }
23160        if remaining != 0u32 {
23161            if !first {
23162                f.write_str(" | ")?;
23163            }
23164            write!(f, "{:#x}", remaining)?;
23165        } else if first {
23166            f.write_str("(empty)")?;
23167        }
23168        Ok(())
23169    }
23170}
23171///[`VkVideoEncodeAV1CapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilityFlagBitsKHR.html)
23172#[repr(transparent)]
23173#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
23174#[doc(alias = "VkVideoEncodeAV1CapabilityFlagBitsKHR")]
23175pub struct VideoEncodeAV1CapabilityFlagBitsKHR(u32);
23176impl VideoEncodeAV1CapabilityFlagBitsKHR {
23177    #[inline]
23178    pub const fn empty() -> Self {
23179        Self(0u32)
23180    }
23181    #[inline]
23182    pub const fn from_raw(value: u32) -> Self {
23183        Self(value)
23184    }
23185    #[inline]
23186    pub const fn as_raw(self) -> u32 {
23187        self.0
23188    }
23189    #[inline]
23190    pub const fn is_empty(self) -> bool {
23191        self.0 == 0u32
23192    }
23193    #[inline]
23194    pub const fn contains(self, other: Self) -> bool {
23195        (self.0 & other.0) == other.0
23196    }
23197    #[inline]
23198    pub const fn all() -> Self {
23199        Self(63u32)
23200    }
23201    ///Bit 0.
23202    pub const PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX: Self = Self(1u32);
23203    ///Bit 1.
23204    pub const GENERATE_OBU_EXTENSION_HEADER: Self = Self(2u32);
23205    ///Bit 2.
23206    pub const PRIMARY_REFERENCE_CDF_ONLY: Self = Self(4u32);
23207    ///Bit 3.
23208    pub const FRAME_SIZE_OVERRIDE: Self = Self(8u32);
23209    ///Bit 4.
23210    pub const MOTION_VECTOR_SCALING: Self = Self(16u32);
23211    ///Bit 5.
23212    pub const COMPOUND_PREDICTION_INTRA_REFRESH: Self = Self(32u32);
23213}
23214impl core::ops::BitOr for VideoEncodeAV1CapabilityFlagBitsKHR {
23215    type Output = Self;
23216    #[inline]
23217    fn bitor(self, rhs: Self) -> Self {
23218        Self(self.0 | rhs.0)
23219    }
23220}
23221impl core::ops::BitOrAssign for VideoEncodeAV1CapabilityFlagBitsKHR {
23222    #[inline]
23223    fn bitor_assign(&mut self, rhs: Self) {
23224        self.0 |= rhs.0;
23225    }
23226}
23227impl core::ops::BitAnd for VideoEncodeAV1CapabilityFlagBitsKHR {
23228    type Output = Self;
23229    #[inline]
23230    fn bitand(self, rhs: Self) -> Self {
23231        Self(self.0 & rhs.0)
23232    }
23233}
23234impl core::ops::BitAndAssign for VideoEncodeAV1CapabilityFlagBitsKHR {
23235    #[inline]
23236    fn bitand_assign(&mut self, rhs: Self) {
23237        self.0 &= rhs.0;
23238    }
23239}
23240impl core::ops::BitXor for VideoEncodeAV1CapabilityFlagBitsKHR {
23241    type Output = Self;
23242    #[inline]
23243    fn bitxor(self, rhs: Self) -> Self {
23244        Self(self.0 ^ rhs.0)
23245    }
23246}
23247impl core::ops::BitXorAssign for VideoEncodeAV1CapabilityFlagBitsKHR {
23248    #[inline]
23249    fn bitxor_assign(&mut self, rhs: Self) {
23250        self.0 ^= rhs.0;
23251    }
23252}
23253impl core::ops::Not for VideoEncodeAV1CapabilityFlagBitsKHR {
23254    type Output = Self;
23255    #[inline]
23256    fn not(self) -> Self {
23257        Self(!self.0)
23258    }
23259}
23260impl core::fmt::Debug for VideoEncodeAV1CapabilityFlagBitsKHR {
23261    #[allow(unused_mut, unused_variables)]
23262    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23263        let mut first = true;
23264        let mut remaining = self.0;
23265        if remaining & Self::PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX.0 != 0 {
23266            if !first {
23267                f.write_str(" | ")?;
23268            }
23269            f.write_str("PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX")?;
23270            remaining &= !Self::PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX.0;
23271            first = false;
23272        }
23273        if remaining & Self::GENERATE_OBU_EXTENSION_HEADER.0 != 0 {
23274            if !first {
23275                f.write_str(" | ")?;
23276            }
23277            f.write_str("GENERATE_OBU_EXTENSION_HEADER")?;
23278            remaining &= !Self::GENERATE_OBU_EXTENSION_HEADER.0;
23279            first = false;
23280        }
23281        if remaining & Self::PRIMARY_REFERENCE_CDF_ONLY.0 != 0 {
23282            if !first {
23283                f.write_str(" | ")?;
23284            }
23285            f.write_str("PRIMARY_REFERENCE_CDF_ONLY")?;
23286            remaining &= !Self::PRIMARY_REFERENCE_CDF_ONLY.0;
23287            first = false;
23288        }
23289        if remaining & Self::FRAME_SIZE_OVERRIDE.0 != 0 {
23290            if !first {
23291                f.write_str(" | ")?;
23292            }
23293            f.write_str("FRAME_SIZE_OVERRIDE")?;
23294            remaining &= !Self::FRAME_SIZE_OVERRIDE.0;
23295            first = false;
23296        }
23297        if remaining & Self::MOTION_VECTOR_SCALING.0 != 0 {
23298            if !first {
23299                f.write_str(" | ")?;
23300            }
23301            f.write_str("MOTION_VECTOR_SCALING")?;
23302            remaining &= !Self::MOTION_VECTOR_SCALING.0;
23303            first = false;
23304        }
23305        if remaining & Self::COMPOUND_PREDICTION_INTRA_REFRESH.0 != 0 {
23306            if !first {
23307                f.write_str(" | ")?;
23308            }
23309            f.write_str("COMPOUND_PREDICTION_INTRA_REFRESH")?;
23310            remaining &= !Self::COMPOUND_PREDICTION_INTRA_REFRESH.0;
23311            first = false;
23312        }
23313        if remaining != 0u32 {
23314            if !first {
23315                f.write_str(" | ")?;
23316            }
23317            write!(f, "{:#x}", remaining)?;
23318        } else if first {
23319            f.write_str("(empty)")?;
23320        }
23321        Ok(())
23322    }
23323}
23324///[`VkVideoEncodeAV1RateControlFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlFlagBitsKHR.html)
23325#[repr(transparent)]
23326#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
23327#[doc(alias = "VkVideoEncodeAV1RateControlFlagBitsKHR")]
23328pub struct VideoEncodeAV1RateControlFlagBitsKHR(u32);
23329impl VideoEncodeAV1RateControlFlagBitsKHR {
23330    #[inline]
23331    pub const fn empty() -> Self {
23332        Self(0u32)
23333    }
23334    #[inline]
23335    pub const fn from_raw(value: u32) -> Self {
23336        Self(value)
23337    }
23338    #[inline]
23339    pub const fn as_raw(self) -> u32 {
23340        self.0
23341    }
23342    #[inline]
23343    pub const fn is_empty(self) -> bool {
23344        self.0 == 0u32
23345    }
23346    #[inline]
23347    pub const fn contains(self, other: Self) -> bool {
23348        (self.0 & other.0) == other.0
23349    }
23350    #[inline]
23351    pub const fn all() -> Self {
23352        Self(15u32)
23353    }
23354    ///Bit 0.
23355    pub const REGULAR_GOP: Self = Self(1u32);
23356    ///Bit 1.
23357    pub const TEMPORAL_LAYER_PATTERN_DYADIC: Self = Self(2u32);
23358    ///Bit 2.
23359    pub const REFERENCE_PATTERN_FLAT: Self = Self(4u32);
23360    ///Bit 3.
23361    pub const REFERENCE_PATTERN_DYADIC: Self = Self(8u32);
23362}
23363impl core::ops::BitOr for VideoEncodeAV1RateControlFlagBitsKHR {
23364    type Output = Self;
23365    #[inline]
23366    fn bitor(self, rhs: Self) -> Self {
23367        Self(self.0 | rhs.0)
23368    }
23369}
23370impl core::ops::BitOrAssign for VideoEncodeAV1RateControlFlagBitsKHR {
23371    #[inline]
23372    fn bitor_assign(&mut self, rhs: Self) {
23373        self.0 |= rhs.0;
23374    }
23375}
23376impl core::ops::BitAnd for VideoEncodeAV1RateControlFlagBitsKHR {
23377    type Output = Self;
23378    #[inline]
23379    fn bitand(self, rhs: Self) -> Self {
23380        Self(self.0 & rhs.0)
23381    }
23382}
23383impl core::ops::BitAndAssign for VideoEncodeAV1RateControlFlagBitsKHR {
23384    #[inline]
23385    fn bitand_assign(&mut self, rhs: Self) {
23386        self.0 &= rhs.0;
23387    }
23388}
23389impl core::ops::BitXor for VideoEncodeAV1RateControlFlagBitsKHR {
23390    type Output = Self;
23391    #[inline]
23392    fn bitxor(self, rhs: Self) -> Self {
23393        Self(self.0 ^ rhs.0)
23394    }
23395}
23396impl core::ops::BitXorAssign for VideoEncodeAV1RateControlFlagBitsKHR {
23397    #[inline]
23398    fn bitxor_assign(&mut self, rhs: Self) {
23399        self.0 ^= rhs.0;
23400    }
23401}
23402impl core::ops::Not for VideoEncodeAV1RateControlFlagBitsKHR {
23403    type Output = Self;
23404    #[inline]
23405    fn not(self) -> Self {
23406        Self(!self.0)
23407    }
23408}
23409impl core::fmt::Debug for VideoEncodeAV1RateControlFlagBitsKHR {
23410    #[allow(unused_mut, unused_variables)]
23411    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23412        let mut first = true;
23413        let mut remaining = self.0;
23414        if remaining & Self::REGULAR_GOP.0 != 0 {
23415            if !first {
23416                f.write_str(" | ")?;
23417            }
23418            f.write_str("REGULAR_GOP")?;
23419            remaining &= !Self::REGULAR_GOP.0;
23420            first = false;
23421        }
23422        if remaining & Self::TEMPORAL_LAYER_PATTERN_DYADIC.0 != 0 {
23423            if !first {
23424                f.write_str(" | ")?;
23425            }
23426            f.write_str("TEMPORAL_LAYER_PATTERN_DYADIC")?;
23427            remaining &= !Self::TEMPORAL_LAYER_PATTERN_DYADIC.0;
23428            first = false;
23429        }
23430        if remaining & Self::REFERENCE_PATTERN_FLAT.0 != 0 {
23431            if !first {
23432                f.write_str(" | ")?;
23433            }
23434            f.write_str("REFERENCE_PATTERN_FLAT")?;
23435            remaining &= !Self::REFERENCE_PATTERN_FLAT.0;
23436            first = false;
23437        }
23438        if remaining & Self::REFERENCE_PATTERN_DYADIC.0 != 0 {
23439            if !first {
23440                f.write_str(" | ")?;
23441            }
23442            f.write_str("REFERENCE_PATTERN_DYADIC")?;
23443            remaining &= !Self::REFERENCE_PATTERN_DYADIC.0;
23444            first = false;
23445        }
23446        if remaining != 0u32 {
23447            if !first {
23448                f.write_str(" | ")?;
23449            }
23450            write!(f, "{:#x}", remaining)?;
23451        } else if first {
23452            f.write_str("(empty)")?;
23453        }
23454        Ok(())
23455    }
23456}
23457///[`VkVideoEncodeAV1StdFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1StdFlagBitsKHR.html)
23458#[repr(transparent)]
23459#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
23460#[doc(alias = "VkVideoEncodeAV1StdFlagBitsKHR")]
23461pub struct VideoEncodeAV1StdFlagBitsKHR(u32);
23462impl VideoEncodeAV1StdFlagBitsKHR {
23463    #[inline]
23464    pub const fn empty() -> Self {
23465        Self(0u32)
23466    }
23467    #[inline]
23468    pub const fn from_raw(value: u32) -> Self {
23469        Self(value)
23470    }
23471    #[inline]
23472    pub const fn as_raw(self) -> u32 {
23473        self.0
23474    }
23475    #[inline]
23476    pub const fn is_empty(self) -> bool {
23477        self.0 == 0u32
23478    }
23479    #[inline]
23480    pub const fn contains(self, other: Self) -> bool {
23481        (self.0 & other.0) == other.0
23482    }
23483    #[inline]
23484    pub const fn all() -> Self {
23485        Self(15u32)
23486    }
23487    ///Bit 0.
23488    pub const UNIFORM_TILE_SPACING_FLAG_SET: Self = Self(1u32);
23489    ///Bit 1.
23490    pub const SKIP_MODE_PRESENT_UNSET: Self = Self(2u32);
23491    ///Bit 2.
23492    pub const PRIMARY_REF_FRAME: Self = Self(4u32);
23493    ///Bit 3.
23494    pub const DELTA_Q: Self = Self(8u32);
23495}
23496impl core::ops::BitOr for VideoEncodeAV1StdFlagBitsKHR {
23497    type Output = Self;
23498    #[inline]
23499    fn bitor(self, rhs: Self) -> Self {
23500        Self(self.0 | rhs.0)
23501    }
23502}
23503impl core::ops::BitOrAssign for VideoEncodeAV1StdFlagBitsKHR {
23504    #[inline]
23505    fn bitor_assign(&mut self, rhs: Self) {
23506        self.0 |= rhs.0;
23507    }
23508}
23509impl core::ops::BitAnd for VideoEncodeAV1StdFlagBitsKHR {
23510    type Output = Self;
23511    #[inline]
23512    fn bitand(self, rhs: Self) -> Self {
23513        Self(self.0 & rhs.0)
23514    }
23515}
23516impl core::ops::BitAndAssign for VideoEncodeAV1StdFlagBitsKHR {
23517    #[inline]
23518    fn bitand_assign(&mut self, rhs: Self) {
23519        self.0 &= rhs.0;
23520    }
23521}
23522impl core::ops::BitXor for VideoEncodeAV1StdFlagBitsKHR {
23523    type Output = Self;
23524    #[inline]
23525    fn bitxor(self, rhs: Self) -> Self {
23526        Self(self.0 ^ rhs.0)
23527    }
23528}
23529impl core::ops::BitXorAssign for VideoEncodeAV1StdFlagBitsKHR {
23530    #[inline]
23531    fn bitxor_assign(&mut self, rhs: Self) {
23532        self.0 ^= rhs.0;
23533    }
23534}
23535impl core::ops::Not for VideoEncodeAV1StdFlagBitsKHR {
23536    type Output = Self;
23537    #[inline]
23538    fn not(self) -> Self {
23539        Self(!self.0)
23540    }
23541}
23542impl core::fmt::Debug for VideoEncodeAV1StdFlagBitsKHR {
23543    #[allow(unused_mut, unused_variables)]
23544    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23545        let mut first = true;
23546        let mut remaining = self.0;
23547        if remaining & Self::UNIFORM_TILE_SPACING_FLAG_SET.0 != 0 {
23548            if !first {
23549                f.write_str(" | ")?;
23550            }
23551            f.write_str("UNIFORM_TILE_SPACING_FLAG_SET")?;
23552            remaining &= !Self::UNIFORM_TILE_SPACING_FLAG_SET.0;
23553            first = false;
23554        }
23555        if remaining & Self::SKIP_MODE_PRESENT_UNSET.0 != 0 {
23556            if !first {
23557                f.write_str(" | ")?;
23558            }
23559            f.write_str("SKIP_MODE_PRESENT_UNSET")?;
23560            remaining &= !Self::SKIP_MODE_PRESENT_UNSET.0;
23561            first = false;
23562        }
23563        if remaining & Self::PRIMARY_REF_FRAME.0 != 0 {
23564            if !first {
23565                f.write_str(" | ")?;
23566            }
23567            f.write_str("PRIMARY_REF_FRAME")?;
23568            remaining &= !Self::PRIMARY_REF_FRAME.0;
23569            first = false;
23570        }
23571        if remaining & Self::DELTA_Q.0 != 0 {
23572            if !first {
23573                f.write_str(" | ")?;
23574            }
23575            f.write_str("DELTA_Q")?;
23576            remaining &= !Self::DELTA_Q.0;
23577            first = false;
23578        }
23579        if remaining != 0u32 {
23580            if !first {
23581                f.write_str(" | ")?;
23582            }
23583            write!(f, "{:#x}", remaining)?;
23584        } else if first {
23585            f.write_str("(empty)")?;
23586        }
23587        Ok(())
23588    }
23589}
23590///[`VkVideoEncodeAV1SuperblockSizeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SuperblockSizeFlagBitsKHR.html)
23591#[repr(transparent)]
23592#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
23593#[doc(alias = "VkVideoEncodeAV1SuperblockSizeFlagBitsKHR")]
23594pub struct VideoEncodeAV1SuperblockSizeFlagBitsKHR(u32);
23595impl VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23596    #[inline]
23597    pub const fn empty() -> Self {
23598        Self(0u32)
23599    }
23600    #[inline]
23601    pub const fn from_raw(value: u32) -> Self {
23602        Self(value)
23603    }
23604    #[inline]
23605    pub const fn as_raw(self) -> u32 {
23606        self.0
23607    }
23608    #[inline]
23609    pub const fn is_empty(self) -> bool {
23610        self.0 == 0u32
23611    }
23612    #[inline]
23613    pub const fn contains(self, other: Self) -> bool {
23614        (self.0 & other.0) == other.0
23615    }
23616    #[inline]
23617    pub const fn all() -> Self {
23618        Self(3u32)
23619    }
23620    ///Bit 0.
23621    pub const _64: Self = Self(1u32);
23622    ///Bit 1.
23623    pub const _128: Self = Self(2u32);
23624}
23625impl core::ops::BitOr for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23626    type Output = Self;
23627    #[inline]
23628    fn bitor(self, rhs: Self) -> Self {
23629        Self(self.0 | rhs.0)
23630    }
23631}
23632impl core::ops::BitOrAssign for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23633    #[inline]
23634    fn bitor_assign(&mut self, rhs: Self) {
23635        self.0 |= rhs.0;
23636    }
23637}
23638impl core::ops::BitAnd for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23639    type Output = Self;
23640    #[inline]
23641    fn bitand(self, rhs: Self) -> Self {
23642        Self(self.0 & rhs.0)
23643    }
23644}
23645impl core::ops::BitAndAssign for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23646    #[inline]
23647    fn bitand_assign(&mut self, rhs: Self) {
23648        self.0 &= rhs.0;
23649    }
23650}
23651impl core::ops::BitXor for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23652    type Output = Self;
23653    #[inline]
23654    fn bitxor(self, rhs: Self) -> Self {
23655        Self(self.0 ^ rhs.0)
23656    }
23657}
23658impl core::ops::BitXorAssign for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23659    #[inline]
23660    fn bitxor_assign(&mut self, rhs: Self) {
23661        self.0 ^= rhs.0;
23662    }
23663}
23664impl core::ops::Not for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23665    type Output = Self;
23666    #[inline]
23667    fn not(self) -> Self {
23668        Self(!self.0)
23669    }
23670}
23671impl core::fmt::Debug for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23672    #[allow(unused_mut, unused_variables)]
23673    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23674        let mut first = true;
23675        let mut remaining = self.0;
23676        if remaining & Self::_64.0 != 0 {
23677            if !first {
23678                f.write_str(" | ")?;
23679            }
23680            f.write_str("_64")?;
23681            remaining &= !Self::_64.0;
23682            first = false;
23683        }
23684        if remaining & Self::_128.0 != 0 {
23685            if !first {
23686                f.write_str(" | ")?;
23687            }
23688            f.write_str("_128")?;
23689            remaining &= !Self::_128.0;
23690            first = false;
23691        }
23692        if remaining != 0u32 {
23693            if !first {
23694                f.write_str(" | ")?;
23695            }
23696            write!(f, "{:#x}", remaining)?;
23697        } else if first {
23698            f.write_str("(empty)")?;
23699        }
23700        Ok(())
23701    }
23702}
23703///[`VkVideoEncodeCapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeCapabilityFlagBitsKHR.html)
23704#[repr(transparent)]
23705#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
23706#[doc(alias = "VkVideoEncodeCapabilityFlagBitsKHR")]
23707pub struct VideoEncodeCapabilityFlagBitsKHR(u32);
23708impl VideoEncodeCapabilityFlagBitsKHR {
23709    #[inline]
23710    pub const fn empty() -> Self {
23711        Self(0u32)
23712    }
23713    #[inline]
23714    pub const fn from_raw(value: u32) -> Self {
23715        Self(value)
23716    }
23717    #[inline]
23718    pub const fn as_raw(self) -> u32 {
23719        self.0
23720    }
23721    #[inline]
23722    pub const fn is_empty(self) -> bool {
23723        self.0 == 0u32
23724    }
23725    #[inline]
23726    pub const fn contains(self, other: Self) -> bool {
23727        (self.0 & other.0) == other.0
23728    }
23729    #[inline]
23730    pub const fn all() -> Self {
23731        Self(15u32)
23732    }
23733    ///Bit 0.
23734    pub const PRECEDING_EXTERNALLY_ENCODED_BYTES: Self = Self(1u32);
23735    ///Bit 1.
23736    pub const INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION: Self = Self(2u32);
23737    ///Bit 2.
23738    pub const QUANTIZATION_DELTA_MAP: Self = Self(4u32);
23739    ///Bit 3.
23740    pub const EMPHASIS_MAP: Self = Self(8u32);
23741}
23742impl core::ops::BitOr for VideoEncodeCapabilityFlagBitsKHR {
23743    type Output = Self;
23744    #[inline]
23745    fn bitor(self, rhs: Self) -> Self {
23746        Self(self.0 | rhs.0)
23747    }
23748}
23749impl core::ops::BitOrAssign for VideoEncodeCapabilityFlagBitsKHR {
23750    #[inline]
23751    fn bitor_assign(&mut self, rhs: Self) {
23752        self.0 |= rhs.0;
23753    }
23754}
23755impl core::ops::BitAnd for VideoEncodeCapabilityFlagBitsKHR {
23756    type Output = Self;
23757    #[inline]
23758    fn bitand(self, rhs: Self) -> Self {
23759        Self(self.0 & rhs.0)
23760    }
23761}
23762impl core::ops::BitAndAssign for VideoEncodeCapabilityFlagBitsKHR {
23763    #[inline]
23764    fn bitand_assign(&mut self, rhs: Self) {
23765        self.0 &= rhs.0;
23766    }
23767}
23768impl core::ops::BitXor for VideoEncodeCapabilityFlagBitsKHR {
23769    type Output = Self;
23770    #[inline]
23771    fn bitxor(self, rhs: Self) -> Self {
23772        Self(self.0 ^ rhs.0)
23773    }
23774}
23775impl core::ops::BitXorAssign for VideoEncodeCapabilityFlagBitsKHR {
23776    #[inline]
23777    fn bitxor_assign(&mut self, rhs: Self) {
23778        self.0 ^= rhs.0;
23779    }
23780}
23781impl core::ops::Not for VideoEncodeCapabilityFlagBitsKHR {
23782    type Output = Self;
23783    #[inline]
23784    fn not(self) -> Self {
23785        Self(!self.0)
23786    }
23787}
23788impl core::fmt::Debug for VideoEncodeCapabilityFlagBitsKHR {
23789    #[allow(unused_mut, unused_variables)]
23790    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23791        let mut first = true;
23792        let mut remaining = self.0;
23793        if remaining & Self::PRECEDING_EXTERNALLY_ENCODED_BYTES.0 != 0 {
23794            if !first {
23795                f.write_str(" | ")?;
23796            }
23797            f.write_str("PRECEDING_EXTERNALLY_ENCODED_BYTES")?;
23798            remaining &= !Self::PRECEDING_EXTERNALLY_ENCODED_BYTES.0;
23799            first = false;
23800        }
23801        if remaining & Self::INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION.0 != 0 {
23802            if !first {
23803                f.write_str(" | ")?;
23804            }
23805            f.write_str("INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION")?;
23806            remaining &= !Self::INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION.0;
23807            first = false;
23808        }
23809        if remaining & Self::QUANTIZATION_DELTA_MAP.0 != 0 {
23810            if !first {
23811                f.write_str(" | ")?;
23812            }
23813            f.write_str("QUANTIZATION_DELTA_MAP")?;
23814            remaining &= !Self::QUANTIZATION_DELTA_MAP.0;
23815            first = false;
23816        }
23817        if remaining & Self::EMPHASIS_MAP.0 != 0 {
23818            if !first {
23819                f.write_str(" | ")?;
23820            }
23821            f.write_str("EMPHASIS_MAP")?;
23822            remaining &= !Self::EMPHASIS_MAP.0;
23823            first = false;
23824        }
23825        if remaining != 0u32 {
23826            if !first {
23827                f.write_str(" | ")?;
23828            }
23829            write!(f, "{:#x}", remaining)?;
23830        } else if first {
23831            f.write_str("(empty)")?;
23832        }
23833        Ok(())
23834    }
23835}
23836///[`VkVideoEncodeContentFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeContentFlagBitsKHR.html)
23837#[repr(transparent)]
23838#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
23839#[doc(alias = "VkVideoEncodeContentFlagBitsKHR")]
23840pub struct VideoEncodeContentFlagBitsKHR(u32);
23841impl VideoEncodeContentFlagBitsKHR {
23842    #[inline]
23843    pub const fn empty() -> Self {
23844        Self(0u32)
23845    }
23846    #[inline]
23847    pub const fn from_raw(value: u32) -> Self {
23848        Self(value)
23849    }
23850    #[inline]
23851    pub const fn as_raw(self) -> u32 {
23852        self.0
23853    }
23854    #[inline]
23855    pub const fn is_empty(self) -> bool {
23856        self.0 == 0u32
23857    }
23858    #[inline]
23859    pub const fn contains(self, other: Self) -> bool {
23860        (self.0 & other.0) == other.0
23861    }
23862    #[inline]
23863    pub const fn all() -> Self {
23864        Self(7u32)
23865    }
23866    pub const DEFAULT: Self = Self(0u32);
23867    ///Bit 0.
23868    pub const CAMERA: Self = Self(1u32);
23869    ///Bit 1.
23870    pub const DESKTOP: Self = Self(2u32);
23871    ///Bit 2.
23872    pub const RENDERED: Self = Self(4u32);
23873}
23874impl core::ops::BitOr for VideoEncodeContentFlagBitsKHR {
23875    type Output = Self;
23876    #[inline]
23877    fn bitor(self, rhs: Self) -> Self {
23878        Self(self.0 | rhs.0)
23879    }
23880}
23881impl core::ops::BitOrAssign for VideoEncodeContentFlagBitsKHR {
23882    #[inline]
23883    fn bitor_assign(&mut self, rhs: Self) {
23884        self.0 |= rhs.0;
23885    }
23886}
23887impl core::ops::BitAnd for VideoEncodeContentFlagBitsKHR {
23888    type Output = Self;
23889    #[inline]
23890    fn bitand(self, rhs: Self) -> Self {
23891        Self(self.0 & rhs.0)
23892    }
23893}
23894impl core::ops::BitAndAssign for VideoEncodeContentFlagBitsKHR {
23895    #[inline]
23896    fn bitand_assign(&mut self, rhs: Self) {
23897        self.0 &= rhs.0;
23898    }
23899}
23900impl core::ops::BitXor for VideoEncodeContentFlagBitsKHR {
23901    type Output = Self;
23902    #[inline]
23903    fn bitxor(self, rhs: Self) -> Self {
23904        Self(self.0 ^ rhs.0)
23905    }
23906}
23907impl core::ops::BitXorAssign for VideoEncodeContentFlagBitsKHR {
23908    #[inline]
23909    fn bitxor_assign(&mut self, rhs: Self) {
23910        self.0 ^= rhs.0;
23911    }
23912}
23913impl core::ops::Not for VideoEncodeContentFlagBitsKHR {
23914    type Output = Self;
23915    #[inline]
23916    fn not(self) -> Self {
23917        Self(!self.0)
23918    }
23919}
23920impl core::fmt::Debug for VideoEncodeContentFlagBitsKHR {
23921    #[allow(unused_mut, unused_variables)]
23922    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23923        let mut first = true;
23924        let mut remaining = self.0;
23925        if remaining & Self::CAMERA.0 != 0 {
23926            if !first {
23927                f.write_str(" | ")?;
23928            }
23929            f.write_str("CAMERA")?;
23930            remaining &= !Self::CAMERA.0;
23931            first = false;
23932        }
23933        if remaining & Self::DESKTOP.0 != 0 {
23934            if !first {
23935                f.write_str(" | ")?;
23936            }
23937            f.write_str("DESKTOP")?;
23938            remaining &= !Self::DESKTOP.0;
23939            first = false;
23940        }
23941        if remaining & Self::RENDERED.0 != 0 {
23942            if !first {
23943                f.write_str(" | ")?;
23944            }
23945            f.write_str("RENDERED")?;
23946            remaining &= !Self::RENDERED.0;
23947            first = false;
23948        }
23949        if remaining != 0u32 {
23950            if !first {
23951                f.write_str(" | ")?;
23952            }
23953            write!(f, "{:#x}", remaining)?;
23954        } else if first {
23955            f.write_str("(empty)")?;
23956        }
23957        Ok(())
23958    }
23959}
23960///[`VkVideoEncodeFeedbackFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFeedbackFlagBitsKHR.html)
23961#[repr(transparent)]
23962#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
23963#[doc(alias = "VkVideoEncodeFeedbackFlagBitsKHR")]
23964pub struct VideoEncodeFeedbackFlagBitsKHR(u32);
23965impl VideoEncodeFeedbackFlagBitsKHR {
23966    #[inline]
23967    pub const fn empty() -> Self {
23968        Self(0u32)
23969    }
23970    #[inline]
23971    pub const fn from_raw(value: u32) -> Self {
23972        Self(value)
23973    }
23974    #[inline]
23975    pub const fn as_raw(self) -> u32 {
23976        self.0
23977    }
23978    #[inline]
23979    pub const fn is_empty(self) -> bool {
23980        self.0 == 0u32
23981    }
23982    #[inline]
23983    pub const fn contains(self, other: Self) -> bool {
23984        (self.0 & other.0) == other.0
23985    }
23986    #[inline]
23987    pub const fn all() -> Self {
23988        Self(7u32)
23989    }
23990    ///Bit 0.
23991    pub const BITSTREAM_BUFFER_OFFSET: Self = Self(1u32);
23992    ///Bit 1.
23993    pub const BITSTREAM_BYTES_WRITTEN: Self = Self(2u32);
23994    ///Bit 2.
23995    pub const BITSTREAM_HAS_OVERRIDES: Self = Self(4u32);
23996}
23997impl core::ops::BitOr for VideoEncodeFeedbackFlagBitsKHR {
23998    type Output = Self;
23999    #[inline]
24000    fn bitor(self, rhs: Self) -> Self {
24001        Self(self.0 | rhs.0)
24002    }
24003}
24004impl core::ops::BitOrAssign for VideoEncodeFeedbackFlagBitsKHR {
24005    #[inline]
24006    fn bitor_assign(&mut self, rhs: Self) {
24007        self.0 |= rhs.0;
24008    }
24009}
24010impl core::ops::BitAnd for VideoEncodeFeedbackFlagBitsKHR {
24011    type Output = Self;
24012    #[inline]
24013    fn bitand(self, rhs: Self) -> Self {
24014        Self(self.0 & rhs.0)
24015    }
24016}
24017impl core::ops::BitAndAssign for VideoEncodeFeedbackFlagBitsKHR {
24018    #[inline]
24019    fn bitand_assign(&mut self, rhs: Self) {
24020        self.0 &= rhs.0;
24021    }
24022}
24023impl core::ops::BitXor for VideoEncodeFeedbackFlagBitsKHR {
24024    type Output = Self;
24025    #[inline]
24026    fn bitxor(self, rhs: Self) -> Self {
24027        Self(self.0 ^ rhs.0)
24028    }
24029}
24030impl core::ops::BitXorAssign for VideoEncodeFeedbackFlagBitsKHR {
24031    #[inline]
24032    fn bitxor_assign(&mut self, rhs: Self) {
24033        self.0 ^= rhs.0;
24034    }
24035}
24036impl core::ops::Not for VideoEncodeFeedbackFlagBitsKHR {
24037    type Output = Self;
24038    #[inline]
24039    fn not(self) -> Self {
24040        Self(!self.0)
24041    }
24042}
24043impl core::fmt::Debug for VideoEncodeFeedbackFlagBitsKHR {
24044    #[allow(unused_mut, unused_variables)]
24045    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24046        let mut first = true;
24047        let mut remaining = self.0;
24048        if remaining & Self::BITSTREAM_BUFFER_OFFSET.0 != 0 {
24049            if !first {
24050                f.write_str(" | ")?;
24051            }
24052            f.write_str("BITSTREAM_BUFFER_OFFSET")?;
24053            remaining &= !Self::BITSTREAM_BUFFER_OFFSET.0;
24054            first = false;
24055        }
24056        if remaining & Self::BITSTREAM_BYTES_WRITTEN.0 != 0 {
24057            if !first {
24058                f.write_str(" | ")?;
24059            }
24060            f.write_str("BITSTREAM_BYTES_WRITTEN")?;
24061            remaining &= !Self::BITSTREAM_BYTES_WRITTEN.0;
24062            first = false;
24063        }
24064        if remaining & Self::BITSTREAM_HAS_OVERRIDES.0 != 0 {
24065            if !first {
24066                f.write_str(" | ")?;
24067            }
24068            f.write_str("BITSTREAM_HAS_OVERRIDES")?;
24069            remaining &= !Self::BITSTREAM_HAS_OVERRIDES.0;
24070            first = false;
24071        }
24072        if remaining != 0u32 {
24073            if !first {
24074                f.write_str(" | ")?;
24075            }
24076            write!(f, "{:#x}", remaining)?;
24077        } else if first {
24078            f.write_str("(empty)")?;
24079        }
24080        Ok(())
24081    }
24082}
24083///[`VkVideoEncodeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFlagBitsKHR.html)
24084#[repr(transparent)]
24085#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
24086#[doc(alias = "VkVideoEncodeFlagBitsKHR")]
24087pub struct VideoEncodeFlagBitsKHR(u32);
24088impl VideoEncodeFlagBitsKHR {
24089    #[inline]
24090    pub const fn empty() -> Self {
24091        Self(0u32)
24092    }
24093    #[inline]
24094    pub const fn from_raw(value: u32) -> Self {
24095        Self(value)
24096    }
24097    #[inline]
24098    pub const fn as_raw(self) -> u32 {
24099        self.0
24100    }
24101    #[inline]
24102    pub const fn is_empty(self) -> bool {
24103        self.0 == 0u32
24104    }
24105    #[inline]
24106    pub const fn contains(self, other: Self) -> bool {
24107        (self.0 & other.0) == other.0
24108    }
24109    #[inline]
24110    pub const fn all() -> Self {
24111        Self(7u32)
24112    }
24113    ///Bit 2.
24114    pub const INTRA_REFRESH: Self = Self(4u32);
24115    ///Bit 0.
24116    pub const WITH_QUANTIZATION_DELTA_MAP: Self = Self(1u32);
24117    ///Bit 1.
24118    pub const WITH_EMPHASIS_MAP: Self = Self(2u32);
24119}
24120impl core::ops::BitOr for VideoEncodeFlagBitsKHR {
24121    type Output = Self;
24122    #[inline]
24123    fn bitor(self, rhs: Self) -> Self {
24124        Self(self.0 | rhs.0)
24125    }
24126}
24127impl core::ops::BitOrAssign for VideoEncodeFlagBitsKHR {
24128    #[inline]
24129    fn bitor_assign(&mut self, rhs: Self) {
24130        self.0 |= rhs.0;
24131    }
24132}
24133impl core::ops::BitAnd for VideoEncodeFlagBitsKHR {
24134    type Output = Self;
24135    #[inline]
24136    fn bitand(self, rhs: Self) -> Self {
24137        Self(self.0 & rhs.0)
24138    }
24139}
24140impl core::ops::BitAndAssign for VideoEncodeFlagBitsKHR {
24141    #[inline]
24142    fn bitand_assign(&mut self, rhs: Self) {
24143        self.0 &= rhs.0;
24144    }
24145}
24146impl core::ops::BitXor for VideoEncodeFlagBitsKHR {
24147    type Output = Self;
24148    #[inline]
24149    fn bitxor(self, rhs: Self) -> Self {
24150        Self(self.0 ^ rhs.0)
24151    }
24152}
24153impl core::ops::BitXorAssign for VideoEncodeFlagBitsKHR {
24154    #[inline]
24155    fn bitxor_assign(&mut self, rhs: Self) {
24156        self.0 ^= rhs.0;
24157    }
24158}
24159impl core::ops::Not for VideoEncodeFlagBitsKHR {
24160    type Output = Self;
24161    #[inline]
24162    fn not(self) -> Self {
24163        Self(!self.0)
24164    }
24165}
24166impl core::fmt::Debug for VideoEncodeFlagBitsKHR {
24167    #[allow(unused_mut, unused_variables)]
24168    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24169        let mut first = true;
24170        let mut remaining = self.0;
24171        if remaining & Self::INTRA_REFRESH.0 != 0 {
24172            if !first {
24173                f.write_str(" | ")?;
24174            }
24175            f.write_str("INTRA_REFRESH")?;
24176            remaining &= !Self::INTRA_REFRESH.0;
24177            first = false;
24178        }
24179        if remaining & Self::WITH_QUANTIZATION_DELTA_MAP.0 != 0 {
24180            if !first {
24181                f.write_str(" | ")?;
24182            }
24183            f.write_str("WITH_QUANTIZATION_DELTA_MAP")?;
24184            remaining &= !Self::WITH_QUANTIZATION_DELTA_MAP.0;
24185            first = false;
24186        }
24187        if remaining & Self::WITH_EMPHASIS_MAP.0 != 0 {
24188            if !first {
24189                f.write_str(" | ")?;
24190            }
24191            f.write_str("WITH_EMPHASIS_MAP")?;
24192            remaining &= !Self::WITH_EMPHASIS_MAP.0;
24193            first = false;
24194        }
24195        if remaining != 0u32 {
24196            if !first {
24197                f.write_str(" | ")?;
24198            }
24199            write!(f, "{:#x}", remaining)?;
24200        } else if first {
24201            f.write_str("(empty)")?;
24202        }
24203        Ok(())
24204    }
24205}
24206///[`VkVideoEncodeH264CapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilityFlagBitsKHR.html)
24207#[repr(transparent)]
24208#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
24209#[doc(alias = "VkVideoEncodeH264CapabilityFlagBitsKHR")]
24210pub struct VideoEncodeH264CapabilityFlagBitsKHR(u32);
24211impl VideoEncodeH264CapabilityFlagBitsKHR {
24212    #[inline]
24213    pub const fn empty() -> Self {
24214        Self(0u32)
24215    }
24216    #[inline]
24217    pub const fn from_raw(value: u32) -> Self {
24218        Self(value)
24219    }
24220    #[inline]
24221    pub const fn as_raw(self) -> u32 {
24222        self.0
24223    }
24224    #[inline]
24225    pub const fn is_empty(self) -> bool {
24226        self.0 == 0u32
24227    }
24228    #[inline]
24229    pub const fn contains(self, other: Self) -> bool {
24230        (self.0 & other.0) == other.0
24231    }
24232    #[inline]
24233    pub const fn all() -> Self {
24234        Self(2047u32)
24235    }
24236    ///Bit 0.
24237    pub const HRD_COMPLIANCE: Self = Self(1u32);
24238    ///Bit 1.
24239    pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(2u32);
24240    ///Bit 2.
24241    pub const ROW_UNALIGNED_SLICE: Self = Self(4u32);
24242    ///Bit 3.
24243    pub const DIFFERENT_SLICE_TYPE: Self = Self(8u32);
24244    ///Bit 4.
24245    pub const B_FRAME_IN_L0_LIST: Self = Self(16u32);
24246    ///Bit 5.
24247    pub const B_FRAME_IN_L1_LIST: Self = Self(32u32);
24248    ///Bit 6.
24249    pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(64u32);
24250    ///Bit 7.
24251    pub const PER_SLICE_CONSTANT_QP: Self = Self(128u32);
24252    ///Bit 8.
24253    pub const GENERATE_PREFIX_NALU: Self = Self(256u32);
24254    ///Bit 10.
24255    pub const B_PICTURE_INTRA_REFRESH: Self = Self(1024u32);
24256    ///Bit 9.
24257    pub const MB_QP_DIFF_WRAPAROUND: Self = Self(512u32);
24258}
24259impl core::ops::BitOr for VideoEncodeH264CapabilityFlagBitsKHR {
24260    type Output = Self;
24261    #[inline]
24262    fn bitor(self, rhs: Self) -> Self {
24263        Self(self.0 | rhs.0)
24264    }
24265}
24266impl core::ops::BitOrAssign for VideoEncodeH264CapabilityFlagBitsKHR {
24267    #[inline]
24268    fn bitor_assign(&mut self, rhs: Self) {
24269        self.0 |= rhs.0;
24270    }
24271}
24272impl core::ops::BitAnd for VideoEncodeH264CapabilityFlagBitsKHR {
24273    type Output = Self;
24274    #[inline]
24275    fn bitand(self, rhs: Self) -> Self {
24276        Self(self.0 & rhs.0)
24277    }
24278}
24279impl core::ops::BitAndAssign for VideoEncodeH264CapabilityFlagBitsKHR {
24280    #[inline]
24281    fn bitand_assign(&mut self, rhs: Self) {
24282        self.0 &= rhs.0;
24283    }
24284}
24285impl core::ops::BitXor for VideoEncodeH264CapabilityFlagBitsKHR {
24286    type Output = Self;
24287    #[inline]
24288    fn bitxor(self, rhs: Self) -> Self {
24289        Self(self.0 ^ rhs.0)
24290    }
24291}
24292impl core::ops::BitXorAssign for VideoEncodeH264CapabilityFlagBitsKHR {
24293    #[inline]
24294    fn bitxor_assign(&mut self, rhs: Self) {
24295        self.0 ^= rhs.0;
24296    }
24297}
24298impl core::ops::Not for VideoEncodeH264CapabilityFlagBitsKHR {
24299    type Output = Self;
24300    #[inline]
24301    fn not(self) -> Self {
24302        Self(!self.0)
24303    }
24304}
24305impl core::fmt::Debug for VideoEncodeH264CapabilityFlagBitsKHR {
24306    #[allow(unused_mut, unused_variables)]
24307    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24308        let mut first = true;
24309        let mut remaining = self.0;
24310        if remaining & Self::HRD_COMPLIANCE.0 != 0 {
24311            if !first {
24312                f.write_str(" | ")?;
24313            }
24314            f.write_str("HRD_COMPLIANCE")?;
24315            remaining &= !Self::HRD_COMPLIANCE.0;
24316            first = false;
24317        }
24318        if remaining & Self::PREDICTION_WEIGHT_TABLE_GENERATED.0 != 0 {
24319            if !first {
24320                f.write_str(" | ")?;
24321            }
24322            f.write_str("PREDICTION_WEIGHT_TABLE_GENERATED")?;
24323            remaining &= !Self::PREDICTION_WEIGHT_TABLE_GENERATED.0;
24324            first = false;
24325        }
24326        if remaining & Self::ROW_UNALIGNED_SLICE.0 != 0 {
24327            if !first {
24328                f.write_str(" | ")?;
24329            }
24330            f.write_str("ROW_UNALIGNED_SLICE")?;
24331            remaining &= !Self::ROW_UNALIGNED_SLICE.0;
24332            first = false;
24333        }
24334        if remaining & Self::DIFFERENT_SLICE_TYPE.0 != 0 {
24335            if !first {
24336                f.write_str(" | ")?;
24337            }
24338            f.write_str("DIFFERENT_SLICE_TYPE")?;
24339            remaining &= !Self::DIFFERENT_SLICE_TYPE.0;
24340            first = false;
24341        }
24342        if remaining & Self::B_FRAME_IN_L0_LIST.0 != 0 {
24343            if !first {
24344                f.write_str(" | ")?;
24345            }
24346            f.write_str("B_FRAME_IN_L0_LIST")?;
24347            remaining &= !Self::B_FRAME_IN_L0_LIST.0;
24348            first = false;
24349        }
24350        if remaining & Self::B_FRAME_IN_L1_LIST.0 != 0 {
24351            if !first {
24352                f.write_str(" | ")?;
24353            }
24354            f.write_str("B_FRAME_IN_L1_LIST")?;
24355            remaining &= !Self::B_FRAME_IN_L1_LIST.0;
24356            first = false;
24357        }
24358        if remaining & Self::PER_PICTURE_TYPE_MIN_MAX_QP.0 != 0 {
24359            if !first {
24360                f.write_str(" | ")?;
24361            }
24362            f.write_str("PER_PICTURE_TYPE_MIN_MAX_QP")?;
24363            remaining &= !Self::PER_PICTURE_TYPE_MIN_MAX_QP.0;
24364            first = false;
24365        }
24366        if remaining & Self::PER_SLICE_CONSTANT_QP.0 != 0 {
24367            if !first {
24368                f.write_str(" | ")?;
24369            }
24370            f.write_str("PER_SLICE_CONSTANT_QP")?;
24371            remaining &= !Self::PER_SLICE_CONSTANT_QP.0;
24372            first = false;
24373        }
24374        if remaining & Self::GENERATE_PREFIX_NALU.0 != 0 {
24375            if !first {
24376                f.write_str(" | ")?;
24377            }
24378            f.write_str("GENERATE_PREFIX_NALU")?;
24379            remaining &= !Self::GENERATE_PREFIX_NALU.0;
24380            first = false;
24381        }
24382        if remaining & Self::B_PICTURE_INTRA_REFRESH.0 != 0 {
24383            if !first {
24384                f.write_str(" | ")?;
24385            }
24386            f.write_str("B_PICTURE_INTRA_REFRESH")?;
24387            remaining &= !Self::B_PICTURE_INTRA_REFRESH.0;
24388            first = false;
24389        }
24390        if remaining & Self::MB_QP_DIFF_WRAPAROUND.0 != 0 {
24391            if !first {
24392                f.write_str(" | ")?;
24393            }
24394            f.write_str("MB_QP_DIFF_WRAPAROUND")?;
24395            remaining &= !Self::MB_QP_DIFF_WRAPAROUND.0;
24396            first = false;
24397        }
24398        if remaining != 0u32 {
24399            if !first {
24400                f.write_str(" | ")?;
24401            }
24402            write!(f, "{:#x}", remaining)?;
24403        } else if first {
24404            f.write_str("(empty)")?;
24405        }
24406        Ok(())
24407    }
24408}
24409///[`VkVideoEncodeH264RateControlFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlFlagBitsKHR.html)
24410#[repr(transparent)]
24411#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
24412#[doc(alias = "VkVideoEncodeH264RateControlFlagBitsKHR")]
24413pub struct VideoEncodeH264RateControlFlagBitsKHR(u32);
24414impl VideoEncodeH264RateControlFlagBitsKHR {
24415    #[inline]
24416    pub const fn empty() -> Self {
24417        Self(0u32)
24418    }
24419    #[inline]
24420    pub const fn from_raw(value: u32) -> Self {
24421        Self(value)
24422    }
24423    #[inline]
24424    pub const fn as_raw(self) -> u32 {
24425        self.0
24426    }
24427    #[inline]
24428    pub const fn is_empty(self) -> bool {
24429        self.0 == 0u32
24430    }
24431    #[inline]
24432    pub const fn contains(self, other: Self) -> bool {
24433        (self.0 & other.0) == other.0
24434    }
24435    #[inline]
24436    pub const fn all() -> Self {
24437        Self(31u32)
24438    }
24439    ///Bit 0.
24440    pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(1u32);
24441    ///Bit 1.
24442    pub const REGULAR_GOP: Self = Self(2u32);
24443    ///Bit 2.
24444    pub const REFERENCE_PATTERN_FLAT: Self = Self(4u32);
24445    ///Bit 3.
24446    pub const REFERENCE_PATTERN_DYADIC: Self = Self(8u32);
24447    ///Bit 4.
24448    pub const TEMPORAL_LAYER_PATTERN_DYADIC: Self = Self(16u32);
24449}
24450impl core::ops::BitOr for VideoEncodeH264RateControlFlagBitsKHR {
24451    type Output = Self;
24452    #[inline]
24453    fn bitor(self, rhs: Self) -> Self {
24454        Self(self.0 | rhs.0)
24455    }
24456}
24457impl core::ops::BitOrAssign for VideoEncodeH264RateControlFlagBitsKHR {
24458    #[inline]
24459    fn bitor_assign(&mut self, rhs: Self) {
24460        self.0 |= rhs.0;
24461    }
24462}
24463impl core::ops::BitAnd for VideoEncodeH264RateControlFlagBitsKHR {
24464    type Output = Self;
24465    #[inline]
24466    fn bitand(self, rhs: Self) -> Self {
24467        Self(self.0 & rhs.0)
24468    }
24469}
24470impl core::ops::BitAndAssign for VideoEncodeH264RateControlFlagBitsKHR {
24471    #[inline]
24472    fn bitand_assign(&mut self, rhs: Self) {
24473        self.0 &= rhs.0;
24474    }
24475}
24476impl core::ops::BitXor for VideoEncodeH264RateControlFlagBitsKHR {
24477    type Output = Self;
24478    #[inline]
24479    fn bitxor(self, rhs: Self) -> Self {
24480        Self(self.0 ^ rhs.0)
24481    }
24482}
24483impl core::ops::BitXorAssign for VideoEncodeH264RateControlFlagBitsKHR {
24484    #[inline]
24485    fn bitxor_assign(&mut self, rhs: Self) {
24486        self.0 ^= rhs.0;
24487    }
24488}
24489impl core::ops::Not for VideoEncodeH264RateControlFlagBitsKHR {
24490    type Output = Self;
24491    #[inline]
24492    fn not(self) -> Self {
24493        Self(!self.0)
24494    }
24495}
24496impl core::fmt::Debug for VideoEncodeH264RateControlFlagBitsKHR {
24497    #[allow(unused_mut, unused_variables)]
24498    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24499        let mut first = true;
24500        let mut remaining = self.0;
24501        if remaining & Self::ATTEMPT_HRD_COMPLIANCE.0 != 0 {
24502            if !first {
24503                f.write_str(" | ")?;
24504            }
24505            f.write_str("ATTEMPT_HRD_COMPLIANCE")?;
24506            remaining &= !Self::ATTEMPT_HRD_COMPLIANCE.0;
24507            first = false;
24508        }
24509        if remaining & Self::REGULAR_GOP.0 != 0 {
24510            if !first {
24511                f.write_str(" | ")?;
24512            }
24513            f.write_str("REGULAR_GOP")?;
24514            remaining &= !Self::REGULAR_GOP.0;
24515            first = false;
24516        }
24517        if remaining & Self::REFERENCE_PATTERN_FLAT.0 != 0 {
24518            if !first {
24519                f.write_str(" | ")?;
24520            }
24521            f.write_str("REFERENCE_PATTERN_FLAT")?;
24522            remaining &= !Self::REFERENCE_PATTERN_FLAT.0;
24523            first = false;
24524        }
24525        if remaining & Self::REFERENCE_PATTERN_DYADIC.0 != 0 {
24526            if !first {
24527                f.write_str(" | ")?;
24528            }
24529            f.write_str("REFERENCE_PATTERN_DYADIC")?;
24530            remaining &= !Self::REFERENCE_PATTERN_DYADIC.0;
24531            first = false;
24532        }
24533        if remaining & Self::TEMPORAL_LAYER_PATTERN_DYADIC.0 != 0 {
24534            if !first {
24535                f.write_str(" | ")?;
24536            }
24537            f.write_str("TEMPORAL_LAYER_PATTERN_DYADIC")?;
24538            remaining &= !Self::TEMPORAL_LAYER_PATTERN_DYADIC.0;
24539            first = false;
24540        }
24541        if remaining != 0u32 {
24542            if !first {
24543                f.write_str(" | ")?;
24544            }
24545            write!(f, "{:#x}", remaining)?;
24546        } else if first {
24547            f.write_str("(empty)")?;
24548        }
24549        Ok(())
24550    }
24551}
24552///[`VkVideoEncodeH264StdFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264StdFlagBitsKHR.html)
24553#[repr(transparent)]
24554#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
24555#[doc(alias = "VkVideoEncodeH264StdFlagBitsKHR")]
24556pub struct VideoEncodeH264StdFlagBitsKHR(u32);
24557impl VideoEncodeH264StdFlagBitsKHR {
24558    #[inline]
24559    pub const fn empty() -> Self {
24560        Self(0u32)
24561    }
24562    #[inline]
24563    pub const fn from_raw(value: u32) -> Self {
24564        Self(value)
24565    }
24566    #[inline]
24567    pub const fn as_raw(self) -> u32 {
24568        self.0
24569    }
24570    #[inline]
24571    pub const fn is_empty(self) -> bool {
24572        self.0 == 0u32
24573    }
24574    #[inline]
24575    pub const fn contains(self, other: Self) -> bool {
24576        (self.0 & other.0) == other.0
24577    }
24578    #[inline]
24579    pub const fn all() -> Self {
24580        Self(1835007u32)
24581    }
24582    ///Bit 0.
24583    pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(1u32);
24584    ///Bit 1.
24585    pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET: Self = Self(2u32);
24586    ///Bit 2.
24587    pub const SCALING_MATRIX_PRESENT_FLAG_SET: Self = Self(4u32);
24588    ///Bit 3.
24589    pub const CHROMA_QP_INDEX_OFFSET: Self = Self(8u32);
24590    ///Bit 4.
24591    pub const SECOND_CHROMA_QP_INDEX_OFFSET: Self = Self(16u32);
24592    ///Bit 5.
24593    pub const PIC_INIT_QP_MINUS26: Self = Self(32u32);
24594    ///Bit 6.
24595    pub const WEIGHTED_PRED_FLAG_SET: Self = Self(64u32);
24596    ///Bit 7.
24597    pub const WEIGHTED_BIPRED_IDC_EXPLICIT: Self = Self(128u32);
24598    ///Bit 8.
24599    pub const WEIGHTED_BIPRED_IDC_IMPLICIT: Self = Self(256u32);
24600    ///Bit 9.
24601    pub const TRANSFORM_8X8_MODE_FLAG_SET: Self = Self(512u32);
24602    ///Bit 10.
24603    pub const DIRECT_SPATIAL_MV_PRED_FLAG_UNSET: Self = Self(1024u32);
24604    ///Bit 11.
24605    pub const ENTROPY_CODING_MODE_FLAG_UNSET: Self = Self(2048u32);
24606    ///Bit 12.
24607    pub const ENTROPY_CODING_MODE_FLAG_SET: Self = Self(4096u32);
24608    ///Bit 13.
24609    pub const DIRECT_8X8_INFERENCE_FLAG_UNSET: Self = Self(8192u32);
24610    ///Bit 14.
24611    pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(16384u32);
24612    ///Bit 15.
24613    pub const DEBLOCKING_FILTER_DISABLED: Self = Self(32768u32);
24614    ///Bit 16.
24615    pub const DEBLOCKING_FILTER_ENABLED: Self = Self(65536u32);
24616    ///Bit 17.
24617    pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(131072u32);
24618    ///Bit 19.
24619    pub const SLICE_QP_DELTA: Self = Self(524288u32);
24620    ///Bit 20.
24621    pub const DIFFERENT_SLICE_QP_DELTA: Self = Self(1048576u32);
24622}
24623impl core::ops::BitOr for VideoEncodeH264StdFlagBitsKHR {
24624    type Output = Self;
24625    #[inline]
24626    fn bitor(self, rhs: Self) -> Self {
24627        Self(self.0 | rhs.0)
24628    }
24629}
24630impl core::ops::BitOrAssign for VideoEncodeH264StdFlagBitsKHR {
24631    #[inline]
24632    fn bitor_assign(&mut self, rhs: Self) {
24633        self.0 |= rhs.0;
24634    }
24635}
24636impl core::ops::BitAnd for VideoEncodeH264StdFlagBitsKHR {
24637    type Output = Self;
24638    #[inline]
24639    fn bitand(self, rhs: Self) -> Self {
24640        Self(self.0 & rhs.0)
24641    }
24642}
24643impl core::ops::BitAndAssign for VideoEncodeH264StdFlagBitsKHR {
24644    #[inline]
24645    fn bitand_assign(&mut self, rhs: Self) {
24646        self.0 &= rhs.0;
24647    }
24648}
24649impl core::ops::BitXor for VideoEncodeH264StdFlagBitsKHR {
24650    type Output = Self;
24651    #[inline]
24652    fn bitxor(self, rhs: Self) -> Self {
24653        Self(self.0 ^ rhs.0)
24654    }
24655}
24656impl core::ops::BitXorAssign for VideoEncodeH264StdFlagBitsKHR {
24657    #[inline]
24658    fn bitxor_assign(&mut self, rhs: Self) {
24659        self.0 ^= rhs.0;
24660    }
24661}
24662impl core::ops::Not for VideoEncodeH264StdFlagBitsKHR {
24663    type Output = Self;
24664    #[inline]
24665    fn not(self) -> Self {
24666        Self(!self.0)
24667    }
24668}
24669impl core::fmt::Debug for VideoEncodeH264StdFlagBitsKHR {
24670    #[allow(unused_mut, unused_variables)]
24671    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24672        let mut first = true;
24673        let mut remaining = self.0;
24674        if remaining & Self::SEPARATE_COLOR_PLANE_FLAG_SET.0 != 0 {
24675            if !first {
24676                f.write_str(" | ")?;
24677            }
24678            f.write_str("SEPARATE_COLOR_PLANE_FLAG_SET")?;
24679            remaining &= !Self::SEPARATE_COLOR_PLANE_FLAG_SET.0;
24680            first = false;
24681        }
24682        if remaining & Self::QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET.0 != 0 {
24683            if !first {
24684                f.write_str(" | ")?;
24685            }
24686            f.write_str("QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET")?;
24687            remaining &= !Self::QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET.0;
24688            first = false;
24689        }
24690        if remaining & Self::SCALING_MATRIX_PRESENT_FLAG_SET.0 != 0 {
24691            if !first {
24692                f.write_str(" | ")?;
24693            }
24694            f.write_str("SCALING_MATRIX_PRESENT_FLAG_SET")?;
24695            remaining &= !Self::SCALING_MATRIX_PRESENT_FLAG_SET.0;
24696            first = false;
24697        }
24698        if remaining & Self::CHROMA_QP_INDEX_OFFSET.0 != 0 {
24699            if !first {
24700                f.write_str(" | ")?;
24701            }
24702            f.write_str("CHROMA_QP_INDEX_OFFSET")?;
24703            remaining &= !Self::CHROMA_QP_INDEX_OFFSET.0;
24704            first = false;
24705        }
24706        if remaining & Self::SECOND_CHROMA_QP_INDEX_OFFSET.0 != 0 {
24707            if !first {
24708                f.write_str(" | ")?;
24709            }
24710            f.write_str("SECOND_CHROMA_QP_INDEX_OFFSET")?;
24711            remaining &= !Self::SECOND_CHROMA_QP_INDEX_OFFSET.0;
24712            first = false;
24713        }
24714        if remaining & Self::PIC_INIT_QP_MINUS26.0 != 0 {
24715            if !first {
24716                f.write_str(" | ")?;
24717            }
24718            f.write_str("PIC_INIT_QP_MINUS26")?;
24719            remaining &= !Self::PIC_INIT_QP_MINUS26.0;
24720            first = false;
24721        }
24722        if remaining & Self::WEIGHTED_PRED_FLAG_SET.0 != 0 {
24723            if !first {
24724                f.write_str(" | ")?;
24725            }
24726            f.write_str("WEIGHTED_PRED_FLAG_SET")?;
24727            remaining &= !Self::WEIGHTED_PRED_FLAG_SET.0;
24728            first = false;
24729        }
24730        if remaining & Self::WEIGHTED_BIPRED_IDC_EXPLICIT.0 != 0 {
24731            if !first {
24732                f.write_str(" | ")?;
24733            }
24734            f.write_str("WEIGHTED_BIPRED_IDC_EXPLICIT")?;
24735            remaining &= !Self::WEIGHTED_BIPRED_IDC_EXPLICIT.0;
24736            first = false;
24737        }
24738        if remaining & Self::WEIGHTED_BIPRED_IDC_IMPLICIT.0 != 0 {
24739            if !first {
24740                f.write_str(" | ")?;
24741            }
24742            f.write_str("WEIGHTED_BIPRED_IDC_IMPLICIT")?;
24743            remaining &= !Self::WEIGHTED_BIPRED_IDC_IMPLICIT.0;
24744            first = false;
24745        }
24746        if remaining & Self::TRANSFORM_8X8_MODE_FLAG_SET.0 != 0 {
24747            if !first {
24748                f.write_str(" | ")?;
24749            }
24750            f.write_str("TRANSFORM_8X8_MODE_FLAG_SET")?;
24751            remaining &= !Self::TRANSFORM_8X8_MODE_FLAG_SET.0;
24752            first = false;
24753        }
24754        if remaining & Self::DIRECT_SPATIAL_MV_PRED_FLAG_UNSET.0 != 0 {
24755            if !first {
24756                f.write_str(" | ")?;
24757            }
24758            f.write_str("DIRECT_SPATIAL_MV_PRED_FLAG_UNSET")?;
24759            remaining &= !Self::DIRECT_SPATIAL_MV_PRED_FLAG_UNSET.0;
24760            first = false;
24761        }
24762        if remaining & Self::ENTROPY_CODING_MODE_FLAG_UNSET.0 != 0 {
24763            if !first {
24764                f.write_str(" | ")?;
24765            }
24766            f.write_str("ENTROPY_CODING_MODE_FLAG_UNSET")?;
24767            remaining &= !Self::ENTROPY_CODING_MODE_FLAG_UNSET.0;
24768            first = false;
24769        }
24770        if remaining & Self::ENTROPY_CODING_MODE_FLAG_SET.0 != 0 {
24771            if !first {
24772                f.write_str(" | ")?;
24773            }
24774            f.write_str("ENTROPY_CODING_MODE_FLAG_SET")?;
24775            remaining &= !Self::ENTROPY_CODING_MODE_FLAG_SET.0;
24776            first = false;
24777        }
24778        if remaining & Self::DIRECT_8X8_INFERENCE_FLAG_UNSET.0 != 0 {
24779            if !first {
24780                f.write_str(" | ")?;
24781            }
24782            f.write_str("DIRECT_8X8_INFERENCE_FLAG_UNSET")?;
24783            remaining &= !Self::DIRECT_8X8_INFERENCE_FLAG_UNSET.0;
24784            first = false;
24785        }
24786        if remaining & Self::CONSTRAINED_INTRA_PRED_FLAG_SET.0 != 0 {
24787            if !first {
24788                f.write_str(" | ")?;
24789            }
24790            f.write_str("CONSTRAINED_INTRA_PRED_FLAG_SET")?;
24791            remaining &= !Self::CONSTRAINED_INTRA_PRED_FLAG_SET.0;
24792            first = false;
24793        }
24794        if remaining & Self::DEBLOCKING_FILTER_DISABLED.0 != 0 {
24795            if !first {
24796                f.write_str(" | ")?;
24797            }
24798            f.write_str("DEBLOCKING_FILTER_DISABLED")?;
24799            remaining &= !Self::DEBLOCKING_FILTER_DISABLED.0;
24800            first = false;
24801        }
24802        if remaining & Self::DEBLOCKING_FILTER_ENABLED.0 != 0 {
24803            if !first {
24804                f.write_str(" | ")?;
24805            }
24806            f.write_str("DEBLOCKING_FILTER_ENABLED")?;
24807            remaining &= !Self::DEBLOCKING_FILTER_ENABLED.0;
24808            first = false;
24809        }
24810        if remaining & Self::DEBLOCKING_FILTER_PARTIAL.0 != 0 {
24811            if !first {
24812                f.write_str(" | ")?;
24813            }
24814            f.write_str("DEBLOCKING_FILTER_PARTIAL")?;
24815            remaining &= !Self::DEBLOCKING_FILTER_PARTIAL.0;
24816            first = false;
24817        }
24818        if remaining & Self::SLICE_QP_DELTA.0 != 0 {
24819            if !first {
24820                f.write_str(" | ")?;
24821            }
24822            f.write_str("SLICE_QP_DELTA")?;
24823            remaining &= !Self::SLICE_QP_DELTA.0;
24824            first = false;
24825        }
24826        if remaining & Self::DIFFERENT_SLICE_QP_DELTA.0 != 0 {
24827            if !first {
24828                f.write_str(" | ")?;
24829            }
24830            f.write_str("DIFFERENT_SLICE_QP_DELTA")?;
24831            remaining &= !Self::DIFFERENT_SLICE_QP_DELTA.0;
24832            first = false;
24833        }
24834        if remaining != 0u32 {
24835            if !first {
24836                f.write_str(" | ")?;
24837            }
24838            write!(f, "{:#x}", remaining)?;
24839        } else if first {
24840            f.write_str("(empty)")?;
24841        }
24842        Ok(())
24843    }
24844}
24845///[`VkVideoEncodeH265CapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilityFlagBitsKHR.html)
24846#[repr(transparent)]
24847#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
24848#[doc(alias = "VkVideoEncodeH265CapabilityFlagBitsKHR")]
24849pub struct VideoEncodeH265CapabilityFlagBitsKHR(u32);
24850impl VideoEncodeH265CapabilityFlagBitsKHR {
24851    #[inline]
24852    pub const fn empty() -> Self {
24853        Self(0u32)
24854    }
24855    #[inline]
24856    pub const fn from_raw(value: u32) -> Self {
24857        Self(value)
24858    }
24859    #[inline]
24860    pub const fn as_raw(self) -> u32 {
24861        self.0
24862    }
24863    #[inline]
24864    pub const fn is_empty(self) -> bool {
24865        self.0 == 0u32
24866    }
24867    #[inline]
24868    pub const fn contains(self, other: Self) -> bool {
24869        (self.0 & other.0) == other.0
24870    }
24871    #[inline]
24872    pub const fn all() -> Self {
24873        Self(4095u32)
24874    }
24875    ///Bit 0.
24876    pub const HRD_COMPLIANCE: Self = Self(1u32);
24877    ///Bit 1.
24878    pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(2u32);
24879    ///Bit 2.
24880    pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(4u32);
24881    ///Bit 3.
24882    pub const DIFFERENT_SLICE_SEGMENT_TYPE: Self = Self(8u32);
24883    ///Bit 4.
24884    pub const B_FRAME_IN_L0_LIST: Self = Self(16u32);
24885    ///Bit 5.
24886    pub const B_FRAME_IN_L1_LIST: Self = Self(32u32);
24887    ///Bit 6.
24888    pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(64u32);
24889    ///Bit 7.
24890    pub const PER_SLICE_SEGMENT_CONSTANT_QP: Self = Self(128u32);
24891    ///Bit 8.
24892    pub const MULTIPLE_TILES_PER_SLICE_SEGMENT: Self = Self(256u32);
24893    ///Bit 9.
24894    pub const MULTIPLE_SLICE_SEGMENTS_PER_TILE: Self = Self(512u32);
24895    ///Bit 11.
24896    pub const B_PICTURE_INTRA_REFRESH: Self = Self(2048u32);
24897    ///Bit 10.
24898    pub const CU_QP_DIFF_WRAPAROUND: Self = Self(1024u32);
24899}
24900impl core::ops::BitOr for VideoEncodeH265CapabilityFlagBitsKHR {
24901    type Output = Self;
24902    #[inline]
24903    fn bitor(self, rhs: Self) -> Self {
24904        Self(self.0 | rhs.0)
24905    }
24906}
24907impl core::ops::BitOrAssign for VideoEncodeH265CapabilityFlagBitsKHR {
24908    #[inline]
24909    fn bitor_assign(&mut self, rhs: Self) {
24910        self.0 |= rhs.0;
24911    }
24912}
24913impl core::ops::BitAnd for VideoEncodeH265CapabilityFlagBitsKHR {
24914    type Output = Self;
24915    #[inline]
24916    fn bitand(self, rhs: Self) -> Self {
24917        Self(self.0 & rhs.0)
24918    }
24919}
24920impl core::ops::BitAndAssign for VideoEncodeH265CapabilityFlagBitsKHR {
24921    #[inline]
24922    fn bitand_assign(&mut self, rhs: Self) {
24923        self.0 &= rhs.0;
24924    }
24925}
24926impl core::ops::BitXor for VideoEncodeH265CapabilityFlagBitsKHR {
24927    type Output = Self;
24928    #[inline]
24929    fn bitxor(self, rhs: Self) -> Self {
24930        Self(self.0 ^ rhs.0)
24931    }
24932}
24933impl core::ops::BitXorAssign for VideoEncodeH265CapabilityFlagBitsKHR {
24934    #[inline]
24935    fn bitxor_assign(&mut self, rhs: Self) {
24936        self.0 ^= rhs.0;
24937    }
24938}
24939impl core::ops::Not for VideoEncodeH265CapabilityFlagBitsKHR {
24940    type Output = Self;
24941    #[inline]
24942    fn not(self) -> Self {
24943        Self(!self.0)
24944    }
24945}
24946impl core::fmt::Debug for VideoEncodeH265CapabilityFlagBitsKHR {
24947    #[allow(unused_mut, unused_variables)]
24948    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24949        let mut first = true;
24950        let mut remaining = self.0;
24951        if remaining & Self::HRD_COMPLIANCE.0 != 0 {
24952            if !first {
24953                f.write_str(" | ")?;
24954            }
24955            f.write_str("HRD_COMPLIANCE")?;
24956            remaining &= !Self::HRD_COMPLIANCE.0;
24957            first = false;
24958        }
24959        if remaining & Self::PREDICTION_WEIGHT_TABLE_GENERATED.0 != 0 {
24960            if !first {
24961                f.write_str(" | ")?;
24962            }
24963            f.write_str("PREDICTION_WEIGHT_TABLE_GENERATED")?;
24964            remaining &= !Self::PREDICTION_WEIGHT_TABLE_GENERATED.0;
24965            first = false;
24966        }
24967        if remaining & Self::ROW_UNALIGNED_SLICE_SEGMENT.0 != 0 {
24968            if !first {
24969                f.write_str(" | ")?;
24970            }
24971            f.write_str("ROW_UNALIGNED_SLICE_SEGMENT")?;
24972            remaining &= !Self::ROW_UNALIGNED_SLICE_SEGMENT.0;
24973            first = false;
24974        }
24975        if remaining & Self::DIFFERENT_SLICE_SEGMENT_TYPE.0 != 0 {
24976            if !first {
24977                f.write_str(" | ")?;
24978            }
24979            f.write_str("DIFFERENT_SLICE_SEGMENT_TYPE")?;
24980            remaining &= !Self::DIFFERENT_SLICE_SEGMENT_TYPE.0;
24981            first = false;
24982        }
24983        if remaining & Self::B_FRAME_IN_L0_LIST.0 != 0 {
24984            if !first {
24985                f.write_str(" | ")?;
24986            }
24987            f.write_str("B_FRAME_IN_L0_LIST")?;
24988            remaining &= !Self::B_FRAME_IN_L0_LIST.0;
24989            first = false;
24990        }
24991        if remaining & Self::B_FRAME_IN_L1_LIST.0 != 0 {
24992            if !first {
24993                f.write_str(" | ")?;
24994            }
24995            f.write_str("B_FRAME_IN_L1_LIST")?;
24996            remaining &= !Self::B_FRAME_IN_L1_LIST.0;
24997            first = false;
24998        }
24999        if remaining & Self::PER_PICTURE_TYPE_MIN_MAX_QP.0 != 0 {
25000            if !first {
25001                f.write_str(" | ")?;
25002            }
25003            f.write_str("PER_PICTURE_TYPE_MIN_MAX_QP")?;
25004            remaining &= !Self::PER_PICTURE_TYPE_MIN_MAX_QP.0;
25005            first = false;
25006        }
25007        if remaining & Self::PER_SLICE_SEGMENT_CONSTANT_QP.0 != 0 {
25008            if !first {
25009                f.write_str(" | ")?;
25010            }
25011            f.write_str("PER_SLICE_SEGMENT_CONSTANT_QP")?;
25012            remaining &= !Self::PER_SLICE_SEGMENT_CONSTANT_QP.0;
25013            first = false;
25014        }
25015        if remaining & Self::MULTIPLE_TILES_PER_SLICE_SEGMENT.0 != 0 {
25016            if !first {
25017                f.write_str(" | ")?;
25018            }
25019            f.write_str("MULTIPLE_TILES_PER_SLICE_SEGMENT")?;
25020            remaining &= !Self::MULTIPLE_TILES_PER_SLICE_SEGMENT.0;
25021            first = false;
25022        }
25023        if remaining & Self::MULTIPLE_SLICE_SEGMENTS_PER_TILE.0 != 0 {
25024            if !first {
25025                f.write_str(" | ")?;
25026            }
25027            f.write_str("MULTIPLE_SLICE_SEGMENTS_PER_TILE")?;
25028            remaining &= !Self::MULTIPLE_SLICE_SEGMENTS_PER_TILE.0;
25029            first = false;
25030        }
25031        if remaining & Self::B_PICTURE_INTRA_REFRESH.0 != 0 {
25032            if !first {
25033                f.write_str(" | ")?;
25034            }
25035            f.write_str("B_PICTURE_INTRA_REFRESH")?;
25036            remaining &= !Self::B_PICTURE_INTRA_REFRESH.0;
25037            first = false;
25038        }
25039        if remaining & Self::CU_QP_DIFF_WRAPAROUND.0 != 0 {
25040            if !first {
25041                f.write_str(" | ")?;
25042            }
25043            f.write_str("CU_QP_DIFF_WRAPAROUND")?;
25044            remaining &= !Self::CU_QP_DIFF_WRAPAROUND.0;
25045            first = false;
25046        }
25047        if remaining != 0u32 {
25048            if !first {
25049                f.write_str(" | ")?;
25050            }
25051            write!(f, "{:#x}", remaining)?;
25052        } else if first {
25053            f.write_str("(empty)")?;
25054        }
25055        Ok(())
25056    }
25057}
25058///[`VkVideoEncodeH265CtbSizeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CtbSizeFlagBitsKHR.html)
25059#[repr(transparent)]
25060#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
25061#[doc(alias = "VkVideoEncodeH265CtbSizeFlagBitsKHR")]
25062pub struct VideoEncodeH265CtbSizeFlagBitsKHR(u32);
25063impl VideoEncodeH265CtbSizeFlagBitsKHR {
25064    #[inline]
25065    pub const fn empty() -> Self {
25066        Self(0u32)
25067    }
25068    #[inline]
25069    pub const fn from_raw(value: u32) -> Self {
25070        Self(value)
25071    }
25072    #[inline]
25073    pub const fn as_raw(self) -> u32 {
25074        self.0
25075    }
25076    #[inline]
25077    pub const fn is_empty(self) -> bool {
25078        self.0 == 0u32
25079    }
25080    #[inline]
25081    pub const fn contains(self, other: Self) -> bool {
25082        (self.0 & other.0) == other.0
25083    }
25084    #[inline]
25085    pub const fn all() -> Self {
25086        Self(7u32)
25087    }
25088    ///Bit 0.
25089    pub const _16: Self = Self(1u32);
25090    ///Bit 1.
25091    pub const _32: Self = Self(2u32);
25092    ///Bit 2.
25093    pub const _64: Self = Self(4u32);
25094}
25095impl core::ops::BitOr for VideoEncodeH265CtbSizeFlagBitsKHR {
25096    type Output = Self;
25097    #[inline]
25098    fn bitor(self, rhs: Self) -> Self {
25099        Self(self.0 | rhs.0)
25100    }
25101}
25102impl core::ops::BitOrAssign for VideoEncodeH265CtbSizeFlagBitsKHR {
25103    #[inline]
25104    fn bitor_assign(&mut self, rhs: Self) {
25105        self.0 |= rhs.0;
25106    }
25107}
25108impl core::ops::BitAnd for VideoEncodeH265CtbSizeFlagBitsKHR {
25109    type Output = Self;
25110    #[inline]
25111    fn bitand(self, rhs: Self) -> Self {
25112        Self(self.0 & rhs.0)
25113    }
25114}
25115impl core::ops::BitAndAssign for VideoEncodeH265CtbSizeFlagBitsKHR {
25116    #[inline]
25117    fn bitand_assign(&mut self, rhs: Self) {
25118        self.0 &= rhs.0;
25119    }
25120}
25121impl core::ops::BitXor for VideoEncodeH265CtbSizeFlagBitsKHR {
25122    type Output = Self;
25123    #[inline]
25124    fn bitxor(self, rhs: Self) -> Self {
25125        Self(self.0 ^ rhs.0)
25126    }
25127}
25128impl core::ops::BitXorAssign for VideoEncodeH265CtbSizeFlagBitsKHR {
25129    #[inline]
25130    fn bitxor_assign(&mut self, rhs: Self) {
25131        self.0 ^= rhs.0;
25132    }
25133}
25134impl core::ops::Not for VideoEncodeH265CtbSizeFlagBitsKHR {
25135    type Output = Self;
25136    #[inline]
25137    fn not(self) -> Self {
25138        Self(!self.0)
25139    }
25140}
25141impl core::fmt::Debug for VideoEncodeH265CtbSizeFlagBitsKHR {
25142    #[allow(unused_mut, unused_variables)]
25143    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25144        let mut first = true;
25145        let mut remaining = self.0;
25146        if remaining & Self::_16.0 != 0 {
25147            if !first {
25148                f.write_str(" | ")?;
25149            }
25150            f.write_str("_16")?;
25151            remaining &= !Self::_16.0;
25152            first = false;
25153        }
25154        if remaining & Self::_32.0 != 0 {
25155            if !first {
25156                f.write_str(" | ")?;
25157            }
25158            f.write_str("_32")?;
25159            remaining &= !Self::_32.0;
25160            first = false;
25161        }
25162        if remaining & Self::_64.0 != 0 {
25163            if !first {
25164                f.write_str(" | ")?;
25165            }
25166            f.write_str("_64")?;
25167            remaining &= !Self::_64.0;
25168            first = false;
25169        }
25170        if remaining != 0u32 {
25171            if !first {
25172                f.write_str(" | ")?;
25173            }
25174            write!(f, "{:#x}", remaining)?;
25175        } else if first {
25176            f.write_str("(empty)")?;
25177        }
25178        Ok(())
25179    }
25180}
25181///[`VkVideoEncodeH265RateControlFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlFlagBitsKHR.html)
25182#[repr(transparent)]
25183#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
25184#[doc(alias = "VkVideoEncodeH265RateControlFlagBitsKHR")]
25185pub struct VideoEncodeH265RateControlFlagBitsKHR(u32);
25186impl VideoEncodeH265RateControlFlagBitsKHR {
25187    #[inline]
25188    pub const fn empty() -> Self {
25189        Self(0u32)
25190    }
25191    #[inline]
25192    pub const fn from_raw(value: u32) -> Self {
25193        Self(value)
25194    }
25195    #[inline]
25196    pub const fn as_raw(self) -> u32 {
25197        self.0
25198    }
25199    #[inline]
25200    pub const fn is_empty(self) -> bool {
25201        self.0 == 0u32
25202    }
25203    #[inline]
25204    pub const fn contains(self, other: Self) -> bool {
25205        (self.0 & other.0) == other.0
25206    }
25207    #[inline]
25208    pub const fn all() -> Self {
25209        Self(31u32)
25210    }
25211    ///Bit 0.
25212    pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(1u32);
25213    ///Bit 1.
25214    pub const REGULAR_GOP: Self = Self(2u32);
25215    ///Bit 2.
25216    pub const REFERENCE_PATTERN_FLAT: Self = Self(4u32);
25217    ///Bit 3.
25218    pub const REFERENCE_PATTERN_DYADIC: Self = Self(8u32);
25219    ///Bit 4.
25220    pub const TEMPORAL_SUB_LAYER_PATTERN_DYADIC: Self = Self(16u32);
25221}
25222impl core::ops::BitOr for VideoEncodeH265RateControlFlagBitsKHR {
25223    type Output = Self;
25224    #[inline]
25225    fn bitor(self, rhs: Self) -> Self {
25226        Self(self.0 | rhs.0)
25227    }
25228}
25229impl core::ops::BitOrAssign for VideoEncodeH265RateControlFlagBitsKHR {
25230    #[inline]
25231    fn bitor_assign(&mut self, rhs: Self) {
25232        self.0 |= rhs.0;
25233    }
25234}
25235impl core::ops::BitAnd for VideoEncodeH265RateControlFlagBitsKHR {
25236    type Output = Self;
25237    #[inline]
25238    fn bitand(self, rhs: Self) -> Self {
25239        Self(self.0 & rhs.0)
25240    }
25241}
25242impl core::ops::BitAndAssign for VideoEncodeH265RateControlFlagBitsKHR {
25243    #[inline]
25244    fn bitand_assign(&mut self, rhs: Self) {
25245        self.0 &= rhs.0;
25246    }
25247}
25248impl core::ops::BitXor for VideoEncodeH265RateControlFlagBitsKHR {
25249    type Output = Self;
25250    #[inline]
25251    fn bitxor(self, rhs: Self) -> Self {
25252        Self(self.0 ^ rhs.0)
25253    }
25254}
25255impl core::ops::BitXorAssign for VideoEncodeH265RateControlFlagBitsKHR {
25256    #[inline]
25257    fn bitxor_assign(&mut self, rhs: Self) {
25258        self.0 ^= rhs.0;
25259    }
25260}
25261impl core::ops::Not for VideoEncodeH265RateControlFlagBitsKHR {
25262    type Output = Self;
25263    #[inline]
25264    fn not(self) -> Self {
25265        Self(!self.0)
25266    }
25267}
25268impl core::fmt::Debug for VideoEncodeH265RateControlFlagBitsKHR {
25269    #[allow(unused_mut, unused_variables)]
25270    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25271        let mut first = true;
25272        let mut remaining = self.0;
25273        if remaining & Self::ATTEMPT_HRD_COMPLIANCE.0 != 0 {
25274            if !first {
25275                f.write_str(" | ")?;
25276            }
25277            f.write_str("ATTEMPT_HRD_COMPLIANCE")?;
25278            remaining &= !Self::ATTEMPT_HRD_COMPLIANCE.0;
25279            first = false;
25280        }
25281        if remaining & Self::REGULAR_GOP.0 != 0 {
25282            if !first {
25283                f.write_str(" | ")?;
25284            }
25285            f.write_str("REGULAR_GOP")?;
25286            remaining &= !Self::REGULAR_GOP.0;
25287            first = false;
25288        }
25289        if remaining & Self::REFERENCE_PATTERN_FLAT.0 != 0 {
25290            if !first {
25291                f.write_str(" | ")?;
25292            }
25293            f.write_str("REFERENCE_PATTERN_FLAT")?;
25294            remaining &= !Self::REFERENCE_PATTERN_FLAT.0;
25295            first = false;
25296        }
25297        if remaining & Self::REFERENCE_PATTERN_DYADIC.0 != 0 {
25298            if !first {
25299                f.write_str(" | ")?;
25300            }
25301            f.write_str("REFERENCE_PATTERN_DYADIC")?;
25302            remaining &= !Self::REFERENCE_PATTERN_DYADIC.0;
25303            first = false;
25304        }
25305        if remaining & Self::TEMPORAL_SUB_LAYER_PATTERN_DYADIC.0 != 0 {
25306            if !first {
25307                f.write_str(" | ")?;
25308            }
25309            f.write_str("TEMPORAL_SUB_LAYER_PATTERN_DYADIC")?;
25310            remaining &= !Self::TEMPORAL_SUB_LAYER_PATTERN_DYADIC.0;
25311            first = false;
25312        }
25313        if remaining != 0u32 {
25314            if !first {
25315                f.write_str(" | ")?;
25316            }
25317            write!(f, "{:#x}", remaining)?;
25318        } else if first {
25319            f.write_str("(empty)")?;
25320        }
25321        Ok(())
25322    }
25323}
25324///[`VkVideoEncodeH265StdFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265StdFlagBitsKHR.html)
25325#[repr(transparent)]
25326#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
25327#[doc(alias = "VkVideoEncodeH265StdFlagBitsKHR")]
25328pub struct VideoEncodeH265StdFlagBitsKHR(u32);
25329impl VideoEncodeH265StdFlagBitsKHR {
25330    #[inline]
25331    pub const fn empty() -> Self {
25332        Self(0u32)
25333    }
25334    #[inline]
25335    pub const fn from_raw(value: u32) -> Self {
25336        Self(value)
25337    }
25338    #[inline]
25339    pub const fn as_raw(self) -> u32 {
25340        self.0
25341    }
25342    #[inline]
25343    pub const fn is_empty(self) -> bool {
25344        self.0 == 0u32
25345    }
25346    #[inline]
25347    pub const fn contains(self, other: Self) -> bool {
25348        (self.0 & other.0) == other.0
25349    }
25350    #[inline]
25351    pub const fn all() -> Self {
25352        Self(2097151u32)
25353    }
25354    ///Bit 0.
25355    pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(1u32);
25356    ///Bit 1.
25357    pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET: Self = Self(2u32);
25358    ///Bit 2.
25359    pub const SCALING_LIST_DATA_PRESENT_FLAG_SET: Self = Self(4u32);
25360    ///Bit 3.
25361    pub const PCM_ENABLED_FLAG_SET: Self = Self(8u32);
25362    ///Bit 4.
25363    pub const SPS_TEMPORAL_MVP_ENABLED_FLAG_SET: Self = Self(16u32);
25364    ///Bit 5.
25365    pub const INIT_QP_MINUS26: Self = Self(32u32);
25366    ///Bit 6.
25367    pub const WEIGHTED_PRED_FLAG_SET: Self = Self(64u32);
25368    ///Bit 7.
25369    pub const WEIGHTED_BIPRED_FLAG_SET: Self = Self(128u32);
25370    ///Bit 8.
25371    pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(256u32);
25372    ///Bit 9.
25373    pub const SIGN_DATA_HIDING_ENABLED_FLAG_SET: Self = Self(512u32);
25374    ///Bit 10.
25375    pub const TRANSFORM_SKIP_ENABLED_FLAG_SET: Self = Self(1024u32);
25376    ///Bit 11.
25377    pub const TRANSFORM_SKIP_ENABLED_FLAG_UNSET: Self = Self(2048u32);
25378    ///Bit 12.
25379    pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET: Self = Self(4096u32);
25380    ///Bit 13.
25381    pub const TRANSQUANT_BYPASS_ENABLED_FLAG_SET: Self = Self(8192u32);
25382    ///Bit 14.
25383    pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(16384u32);
25384    ///Bit 15.
25385    pub const ENTROPY_CODING_SYNC_ENABLED_FLAG_SET: Self = Self(32768u32);
25386    ///Bit 16.
25387    pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET: Self = Self(65536u32);
25388    ///Bit 17.
25389    pub const DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET: Self = Self(131072u32);
25390    ///Bit 18.
25391    pub const DEPENDENT_SLICE_SEGMENT_FLAG_SET: Self = Self(262144u32);
25392    ///Bit 19.
25393    pub const SLICE_QP_DELTA: Self = Self(524288u32);
25394    ///Bit 20.
25395    pub const DIFFERENT_SLICE_QP_DELTA: Self = Self(1048576u32);
25396}
25397impl core::ops::BitOr for VideoEncodeH265StdFlagBitsKHR {
25398    type Output = Self;
25399    #[inline]
25400    fn bitor(self, rhs: Self) -> Self {
25401        Self(self.0 | rhs.0)
25402    }
25403}
25404impl core::ops::BitOrAssign for VideoEncodeH265StdFlagBitsKHR {
25405    #[inline]
25406    fn bitor_assign(&mut self, rhs: Self) {
25407        self.0 |= rhs.0;
25408    }
25409}
25410impl core::ops::BitAnd for VideoEncodeH265StdFlagBitsKHR {
25411    type Output = Self;
25412    #[inline]
25413    fn bitand(self, rhs: Self) -> Self {
25414        Self(self.0 & rhs.0)
25415    }
25416}
25417impl core::ops::BitAndAssign for VideoEncodeH265StdFlagBitsKHR {
25418    #[inline]
25419    fn bitand_assign(&mut self, rhs: Self) {
25420        self.0 &= rhs.0;
25421    }
25422}
25423impl core::ops::BitXor for VideoEncodeH265StdFlagBitsKHR {
25424    type Output = Self;
25425    #[inline]
25426    fn bitxor(self, rhs: Self) -> Self {
25427        Self(self.0 ^ rhs.0)
25428    }
25429}
25430impl core::ops::BitXorAssign for VideoEncodeH265StdFlagBitsKHR {
25431    #[inline]
25432    fn bitxor_assign(&mut self, rhs: Self) {
25433        self.0 ^= rhs.0;
25434    }
25435}
25436impl core::ops::Not for VideoEncodeH265StdFlagBitsKHR {
25437    type Output = Self;
25438    #[inline]
25439    fn not(self) -> Self {
25440        Self(!self.0)
25441    }
25442}
25443impl core::fmt::Debug for VideoEncodeH265StdFlagBitsKHR {
25444    #[allow(unused_mut, unused_variables)]
25445    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25446        let mut first = true;
25447        let mut remaining = self.0;
25448        if remaining & Self::SEPARATE_COLOR_PLANE_FLAG_SET.0 != 0 {
25449            if !first {
25450                f.write_str(" | ")?;
25451            }
25452            f.write_str("SEPARATE_COLOR_PLANE_FLAG_SET")?;
25453            remaining &= !Self::SEPARATE_COLOR_PLANE_FLAG_SET.0;
25454            first = false;
25455        }
25456        if remaining & Self::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET.0 != 0 {
25457            if !first {
25458                f.write_str(" | ")?;
25459            }
25460            f.write_str("SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET")?;
25461            remaining &= !Self::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET.0;
25462            first = false;
25463        }
25464        if remaining & Self::SCALING_LIST_DATA_PRESENT_FLAG_SET.0 != 0 {
25465            if !first {
25466                f.write_str(" | ")?;
25467            }
25468            f.write_str("SCALING_LIST_DATA_PRESENT_FLAG_SET")?;
25469            remaining &= !Self::SCALING_LIST_DATA_PRESENT_FLAG_SET.0;
25470            first = false;
25471        }
25472        if remaining & Self::PCM_ENABLED_FLAG_SET.0 != 0 {
25473            if !first {
25474                f.write_str(" | ")?;
25475            }
25476            f.write_str("PCM_ENABLED_FLAG_SET")?;
25477            remaining &= !Self::PCM_ENABLED_FLAG_SET.0;
25478            first = false;
25479        }
25480        if remaining & Self::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET.0 != 0 {
25481            if !first {
25482                f.write_str(" | ")?;
25483            }
25484            f.write_str("SPS_TEMPORAL_MVP_ENABLED_FLAG_SET")?;
25485            remaining &= !Self::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET.0;
25486            first = false;
25487        }
25488        if remaining & Self::INIT_QP_MINUS26.0 != 0 {
25489            if !first {
25490                f.write_str(" | ")?;
25491            }
25492            f.write_str("INIT_QP_MINUS26")?;
25493            remaining &= !Self::INIT_QP_MINUS26.0;
25494            first = false;
25495        }
25496        if remaining & Self::WEIGHTED_PRED_FLAG_SET.0 != 0 {
25497            if !first {
25498                f.write_str(" | ")?;
25499            }
25500            f.write_str("WEIGHTED_PRED_FLAG_SET")?;
25501            remaining &= !Self::WEIGHTED_PRED_FLAG_SET.0;
25502            first = false;
25503        }
25504        if remaining & Self::WEIGHTED_BIPRED_FLAG_SET.0 != 0 {
25505            if !first {
25506                f.write_str(" | ")?;
25507            }
25508            f.write_str("WEIGHTED_BIPRED_FLAG_SET")?;
25509            remaining &= !Self::WEIGHTED_BIPRED_FLAG_SET.0;
25510            first = false;
25511        }
25512        if remaining & Self::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0 != 0 {
25513            if !first {
25514                f.write_str(" | ")?;
25515            }
25516            f.write_str("LOG2_PARALLEL_MERGE_LEVEL_MINUS2")?;
25517            remaining &= !Self::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0;
25518            first = false;
25519        }
25520        if remaining & Self::SIGN_DATA_HIDING_ENABLED_FLAG_SET.0 != 0 {
25521            if !first {
25522                f.write_str(" | ")?;
25523            }
25524            f.write_str("SIGN_DATA_HIDING_ENABLED_FLAG_SET")?;
25525            remaining &= !Self::SIGN_DATA_HIDING_ENABLED_FLAG_SET.0;
25526            first = false;
25527        }
25528        if remaining & Self::TRANSFORM_SKIP_ENABLED_FLAG_SET.0 != 0 {
25529            if !first {
25530                f.write_str(" | ")?;
25531            }
25532            f.write_str("TRANSFORM_SKIP_ENABLED_FLAG_SET")?;
25533            remaining &= !Self::TRANSFORM_SKIP_ENABLED_FLAG_SET.0;
25534            first = false;
25535        }
25536        if remaining & Self::TRANSFORM_SKIP_ENABLED_FLAG_UNSET.0 != 0 {
25537            if !first {
25538                f.write_str(" | ")?;
25539            }
25540            f.write_str("TRANSFORM_SKIP_ENABLED_FLAG_UNSET")?;
25541            remaining &= !Self::TRANSFORM_SKIP_ENABLED_FLAG_UNSET.0;
25542            first = false;
25543        }
25544        if remaining & Self::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET.0 != 0 {
25545            if !first {
25546                f.write_str(" | ")?;
25547            }
25548            f.write_str("PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET")?;
25549            remaining &= !Self::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET.0;
25550            first = false;
25551        }
25552        if remaining & Self::TRANSQUANT_BYPASS_ENABLED_FLAG_SET.0 != 0 {
25553            if !first {
25554                f.write_str(" | ")?;
25555            }
25556            f.write_str("TRANSQUANT_BYPASS_ENABLED_FLAG_SET")?;
25557            remaining &= !Self::TRANSQUANT_BYPASS_ENABLED_FLAG_SET.0;
25558            first = false;
25559        }
25560        if remaining & Self::CONSTRAINED_INTRA_PRED_FLAG_SET.0 != 0 {
25561            if !first {
25562                f.write_str(" | ")?;
25563            }
25564            f.write_str("CONSTRAINED_INTRA_PRED_FLAG_SET")?;
25565            remaining &= !Self::CONSTRAINED_INTRA_PRED_FLAG_SET.0;
25566            first = false;
25567        }
25568        if remaining & Self::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET.0 != 0 {
25569            if !first {
25570                f.write_str(" | ")?;
25571            }
25572            f.write_str("ENTROPY_CODING_SYNC_ENABLED_FLAG_SET")?;
25573            remaining &= !Self::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET.0;
25574            first = false;
25575        }
25576        if remaining & Self::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET.0 != 0 {
25577            if !first {
25578                f.write_str(" | ")?;
25579            }
25580            f.write_str("DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET")?;
25581            remaining &= !Self::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET.0;
25582            first = false;
25583        }
25584        if remaining & Self::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET.0 != 0 {
25585            if !first {
25586                f.write_str(" | ")?;
25587            }
25588            f.write_str("DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET")?;
25589            remaining &= !Self::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET.0;
25590            first = false;
25591        }
25592        if remaining & Self::DEPENDENT_SLICE_SEGMENT_FLAG_SET.0 != 0 {
25593            if !first {
25594                f.write_str(" | ")?;
25595            }
25596            f.write_str("DEPENDENT_SLICE_SEGMENT_FLAG_SET")?;
25597            remaining &= !Self::DEPENDENT_SLICE_SEGMENT_FLAG_SET.0;
25598            first = false;
25599        }
25600        if remaining & Self::SLICE_QP_DELTA.0 != 0 {
25601            if !first {
25602                f.write_str(" | ")?;
25603            }
25604            f.write_str("SLICE_QP_DELTA")?;
25605            remaining &= !Self::SLICE_QP_DELTA.0;
25606            first = false;
25607        }
25608        if remaining & Self::DIFFERENT_SLICE_QP_DELTA.0 != 0 {
25609            if !first {
25610                f.write_str(" | ")?;
25611            }
25612            f.write_str("DIFFERENT_SLICE_QP_DELTA")?;
25613            remaining &= !Self::DIFFERENT_SLICE_QP_DELTA.0;
25614            first = false;
25615        }
25616        if remaining != 0u32 {
25617            if !first {
25618                f.write_str(" | ")?;
25619            }
25620            write!(f, "{:#x}", remaining)?;
25621        } else if first {
25622            f.write_str("(empty)")?;
25623        }
25624        Ok(())
25625    }
25626}
25627///[`VkVideoEncodeH265TransformBlockSizeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265TransformBlockSizeFlagBitsKHR.html)
25628#[repr(transparent)]
25629#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
25630#[doc(alias = "VkVideoEncodeH265TransformBlockSizeFlagBitsKHR")]
25631pub struct VideoEncodeH265TransformBlockSizeFlagBitsKHR(u32);
25632impl VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25633    #[inline]
25634    pub const fn empty() -> Self {
25635        Self(0u32)
25636    }
25637    #[inline]
25638    pub const fn from_raw(value: u32) -> Self {
25639        Self(value)
25640    }
25641    #[inline]
25642    pub const fn as_raw(self) -> u32 {
25643        self.0
25644    }
25645    #[inline]
25646    pub const fn is_empty(self) -> bool {
25647        self.0 == 0u32
25648    }
25649    #[inline]
25650    pub const fn contains(self, other: Self) -> bool {
25651        (self.0 & other.0) == other.0
25652    }
25653    #[inline]
25654    pub const fn all() -> Self {
25655        Self(15u32)
25656    }
25657    ///Bit 0.
25658    pub const _4: Self = Self(1u32);
25659    ///Bit 1.
25660    pub const _8: Self = Self(2u32);
25661    ///Bit 2.
25662    pub const _16: Self = Self(4u32);
25663    ///Bit 3.
25664    pub const _32: Self = Self(8u32);
25665}
25666impl core::ops::BitOr for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25667    type Output = Self;
25668    #[inline]
25669    fn bitor(self, rhs: Self) -> Self {
25670        Self(self.0 | rhs.0)
25671    }
25672}
25673impl core::ops::BitOrAssign for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25674    #[inline]
25675    fn bitor_assign(&mut self, rhs: Self) {
25676        self.0 |= rhs.0;
25677    }
25678}
25679impl core::ops::BitAnd for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25680    type Output = Self;
25681    #[inline]
25682    fn bitand(self, rhs: Self) -> Self {
25683        Self(self.0 & rhs.0)
25684    }
25685}
25686impl core::ops::BitAndAssign for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25687    #[inline]
25688    fn bitand_assign(&mut self, rhs: Self) {
25689        self.0 &= rhs.0;
25690    }
25691}
25692impl core::ops::BitXor for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25693    type Output = Self;
25694    #[inline]
25695    fn bitxor(self, rhs: Self) -> Self {
25696        Self(self.0 ^ rhs.0)
25697    }
25698}
25699impl core::ops::BitXorAssign for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25700    #[inline]
25701    fn bitxor_assign(&mut self, rhs: Self) {
25702        self.0 ^= rhs.0;
25703    }
25704}
25705impl core::ops::Not for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25706    type Output = Self;
25707    #[inline]
25708    fn not(self) -> Self {
25709        Self(!self.0)
25710    }
25711}
25712impl core::fmt::Debug for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25713    #[allow(unused_mut, unused_variables)]
25714    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25715        let mut first = true;
25716        let mut remaining = self.0;
25717        if remaining & Self::_4.0 != 0 {
25718            if !first {
25719                f.write_str(" | ")?;
25720            }
25721            f.write_str("_4")?;
25722            remaining &= !Self::_4.0;
25723            first = false;
25724        }
25725        if remaining & Self::_8.0 != 0 {
25726            if !first {
25727                f.write_str(" | ")?;
25728            }
25729            f.write_str("_8")?;
25730            remaining &= !Self::_8.0;
25731            first = false;
25732        }
25733        if remaining & Self::_16.0 != 0 {
25734            if !first {
25735                f.write_str(" | ")?;
25736            }
25737            f.write_str("_16")?;
25738            remaining &= !Self::_16.0;
25739            first = false;
25740        }
25741        if remaining & Self::_32.0 != 0 {
25742            if !first {
25743                f.write_str(" | ")?;
25744            }
25745            f.write_str("_32")?;
25746            remaining &= !Self::_32.0;
25747            first = false;
25748        }
25749        if remaining != 0u32 {
25750            if !first {
25751                f.write_str(" | ")?;
25752            }
25753            write!(f, "{:#x}", remaining)?;
25754        } else if first {
25755            f.write_str("(empty)")?;
25756        }
25757        Ok(())
25758    }
25759}
25760///[`VkVideoEncodeIntraRefreshModeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshModeFlagBitsKHR.html)
25761#[repr(transparent)]
25762#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
25763#[doc(alias = "VkVideoEncodeIntraRefreshModeFlagBitsKHR")]
25764pub struct VideoEncodeIntraRefreshModeFlagBitsKHR(u32);
25765impl VideoEncodeIntraRefreshModeFlagBitsKHR {
25766    #[inline]
25767    pub const fn empty() -> Self {
25768        Self(0u32)
25769    }
25770    #[inline]
25771    pub const fn from_raw(value: u32) -> Self {
25772        Self(value)
25773    }
25774    #[inline]
25775    pub const fn as_raw(self) -> u32 {
25776        self.0
25777    }
25778    #[inline]
25779    pub const fn is_empty(self) -> bool {
25780        self.0 == 0u32
25781    }
25782    #[inline]
25783    pub const fn contains(self, other: Self) -> bool {
25784        (self.0 & other.0) == other.0
25785    }
25786    #[inline]
25787    pub const fn all() -> Self {
25788        Self(15u32)
25789    }
25790    pub const NONE: Self = Self(0u32);
25791    ///Bit 0.
25792    pub const PER_PICTURE_PARTITION: Self = Self(1u32);
25793    ///Bit 1.
25794    pub const BLOCK_BASED: Self = Self(2u32);
25795    ///Bit 2.
25796    pub const BLOCK_ROW_BASED: Self = Self(4u32);
25797    ///Bit 3.
25798    pub const BLOCK_COLUMN_BASED: Self = Self(8u32);
25799}
25800impl core::ops::BitOr for VideoEncodeIntraRefreshModeFlagBitsKHR {
25801    type Output = Self;
25802    #[inline]
25803    fn bitor(self, rhs: Self) -> Self {
25804        Self(self.0 | rhs.0)
25805    }
25806}
25807impl core::ops::BitOrAssign for VideoEncodeIntraRefreshModeFlagBitsKHR {
25808    #[inline]
25809    fn bitor_assign(&mut self, rhs: Self) {
25810        self.0 |= rhs.0;
25811    }
25812}
25813impl core::ops::BitAnd for VideoEncodeIntraRefreshModeFlagBitsKHR {
25814    type Output = Self;
25815    #[inline]
25816    fn bitand(self, rhs: Self) -> Self {
25817        Self(self.0 & rhs.0)
25818    }
25819}
25820impl core::ops::BitAndAssign for VideoEncodeIntraRefreshModeFlagBitsKHR {
25821    #[inline]
25822    fn bitand_assign(&mut self, rhs: Self) {
25823        self.0 &= rhs.0;
25824    }
25825}
25826impl core::ops::BitXor for VideoEncodeIntraRefreshModeFlagBitsKHR {
25827    type Output = Self;
25828    #[inline]
25829    fn bitxor(self, rhs: Self) -> Self {
25830        Self(self.0 ^ rhs.0)
25831    }
25832}
25833impl core::ops::BitXorAssign for VideoEncodeIntraRefreshModeFlagBitsKHR {
25834    #[inline]
25835    fn bitxor_assign(&mut self, rhs: Self) {
25836        self.0 ^= rhs.0;
25837    }
25838}
25839impl core::ops::Not for VideoEncodeIntraRefreshModeFlagBitsKHR {
25840    type Output = Self;
25841    #[inline]
25842    fn not(self) -> Self {
25843        Self(!self.0)
25844    }
25845}
25846impl core::fmt::Debug for VideoEncodeIntraRefreshModeFlagBitsKHR {
25847    #[allow(unused_mut, unused_variables)]
25848    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25849        let mut first = true;
25850        let mut remaining = self.0;
25851        if remaining & Self::PER_PICTURE_PARTITION.0 != 0 {
25852            if !first {
25853                f.write_str(" | ")?;
25854            }
25855            f.write_str("PER_PICTURE_PARTITION")?;
25856            remaining &= !Self::PER_PICTURE_PARTITION.0;
25857            first = false;
25858        }
25859        if remaining & Self::BLOCK_BASED.0 != 0 {
25860            if !first {
25861                f.write_str(" | ")?;
25862            }
25863            f.write_str("BLOCK_BASED")?;
25864            remaining &= !Self::BLOCK_BASED.0;
25865            first = false;
25866        }
25867        if remaining & Self::BLOCK_ROW_BASED.0 != 0 {
25868            if !first {
25869                f.write_str(" | ")?;
25870            }
25871            f.write_str("BLOCK_ROW_BASED")?;
25872            remaining &= !Self::BLOCK_ROW_BASED.0;
25873            first = false;
25874        }
25875        if remaining & Self::BLOCK_COLUMN_BASED.0 != 0 {
25876            if !first {
25877                f.write_str(" | ")?;
25878            }
25879            f.write_str("BLOCK_COLUMN_BASED")?;
25880            remaining &= !Self::BLOCK_COLUMN_BASED.0;
25881            first = false;
25882        }
25883        if remaining != 0u32 {
25884            if !first {
25885                f.write_str(" | ")?;
25886            }
25887            write!(f, "{:#x}", remaining)?;
25888        } else if first {
25889            f.write_str("(empty)")?;
25890        }
25891        Ok(())
25892    }
25893}
25894///[`VkVideoEncodeRateControlModeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html)
25895#[repr(transparent)]
25896#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
25897#[doc(alias = "VkVideoEncodeRateControlModeFlagBitsKHR")]
25898pub struct VideoEncodeRateControlModeFlagBitsKHR(u32);
25899impl VideoEncodeRateControlModeFlagBitsKHR {
25900    #[inline]
25901    pub const fn empty() -> Self {
25902        Self(0u32)
25903    }
25904    #[inline]
25905    pub const fn from_raw(value: u32) -> Self {
25906        Self(value)
25907    }
25908    #[inline]
25909    pub const fn as_raw(self) -> u32 {
25910        self.0
25911    }
25912    #[inline]
25913    pub const fn is_empty(self) -> bool {
25914        self.0 == 0u32
25915    }
25916    #[inline]
25917    pub const fn contains(self, other: Self) -> bool {
25918        (self.0 & other.0) == other.0
25919    }
25920    #[inline]
25921    pub const fn all() -> Self {
25922        Self(7u32)
25923    }
25924    pub const DEFAULT: Self = Self(0u32);
25925    ///Bit 0.
25926    pub const DISABLED: Self = Self(1u32);
25927    ///Bit 1.
25928    pub const CBR: Self = Self(2u32);
25929    ///Bit 2.
25930    pub const VBR: Self = Self(4u32);
25931}
25932impl core::ops::BitOr for VideoEncodeRateControlModeFlagBitsKHR {
25933    type Output = Self;
25934    #[inline]
25935    fn bitor(self, rhs: Self) -> Self {
25936        Self(self.0 | rhs.0)
25937    }
25938}
25939impl core::ops::BitOrAssign for VideoEncodeRateControlModeFlagBitsKHR {
25940    #[inline]
25941    fn bitor_assign(&mut self, rhs: Self) {
25942        self.0 |= rhs.0;
25943    }
25944}
25945impl core::ops::BitAnd for VideoEncodeRateControlModeFlagBitsKHR {
25946    type Output = Self;
25947    #[inline]
25948    fn bitand(self, rhs: Self) -> Self {
25949        Self(self.0 & rhs.0)
25950    }
25951}
25952impl core::ops::BitAndAssign for VideoEncodeRateControlModeFlagBitsKHR {
25953    #[inline]
25954    fn bitand_assign(&mut self, rhs: Self) {
25955        self.0 &= rhs.0;
25956    }
25957}
25958impl core::ops::BitXor for VideoEncodeRateControlModeFlagBitsKHR {
25959    type Output = Self;
25960    #[inline]
25961    fn bitxor(self, rhs: Self) -> Self {
25962        Self(self.0 ^ rhs.0)
25963    }
25964}
25965impl core::ops::BitXorAssign for VideoEncodeRateControlModeFlagBitsKHR {
25966    #[inline]
25967    fn bitxor_assign(&mut self, rhs: Self) {
25968        self.0 ^= rhs.0;
25969    }
25970}
25971impl core::ops::Not for VideoEncodeRateControlModeFlagBitsKHR {
25972    type Output = Self;
25973    #[inline]
25974    fn not(self) -> Self {
25975        Self(!self.0)
25976    }
25977}
25978impl core::fmt::Debug for VideoEncodeRateControlModeFlagBitsKHR {
25979    #[allow(unused_mut, unused_variables)]
25980    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25981        let mut first = true;
25982        let mut remaining = self.0;
25983        if remaining & Self::DISABLED.0 != 0 {
25984            if !first {
25985                f.write_str(" | ")?;
25986            }
25987            f.write_str("DISABLED")?;
25988            remaining &= !Self::DISABLED.0;
25989            first = false;
25990        }
25991        if remaining & Self::CBR.0 != 0 {
25992            if !first {
25993                f.write_str(" | ")?;
25994            }
25995            f.write_str("CBR")?;
25996            remaining &= !Self::CBR.0;
25997            first = false;
25998        }
25999        if remaining & Self::VBR.0 != 0 {
26000            if !first {
26001                f.write_str(" | ")?;
26002            }
26003            f.write_str("VBR")?;
26004            remaining &= !Self::VBR.0;
26005            first = false;
26006        }
26007        if remaining != 0u32 {
26008            if !first {
26009                f.write_str(" | ")?;
26010            }
26011            write!(f, "{:#x}", remaining)?;
26012        } else if first {
26013            f.write_str("(empty)")?;
26014        }
26015        Ok(())
26016    }
26017}
26018///[`VkVideoEncodeRgbChromaOffsetFlagBitsVALVE`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbChromaOffsetFlagBitsVALVE.html)
26019#[repr(transparent)]
26020#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
26021#[doc(alias = "VkVideoEncodeRgbChromaOffsetFlagBitsVALVE")]
26022pub struct VideoEncodeRgbChromaOffsetFlagBitsVALVE(u32);
26023impl VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26024    #[inline]
26025    pub const fn empty() -> Self {
26026        Self(0u32)
26027    }
26028    #[inline]
26029    pub const fn from_raw(value: u32) -> Self {
26030        Self(value)
26031    }
26032    #[inline]
26033    pub const fn as_raw(self) -> u32 {
26034        self.0
26035    }
26036    #[inline]
26037    pub const fn is_empty(self) -> bool {
26038        self.0 == 0u32
26039    }
26040    #[inline]
26041    pub const fn contains(self, other: Self) -> bool {
26042        (self.0 & other.0) == other.0
26043    }
26044    #[inline]
26045    pub const fn all() -> Self {
26046        Self(3u32)
26047    }
26048    ///Bit 0.
26049    pub const COSITED_EVEN_BIT: Self = Self(1u32);
26050    ///Bit 1.
26051    pub const MIDPOINT_BIT: Self = Self(2u32);
26052}
26053impl core::ops::BitOr for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26054    type Output = Self;
26055    #[inline]
26056    fn bitor(self, rhs: Self) -> Self {
26057        Self(self.0 | rhs.0)
26058    }
26059}
26060impl core::ops::BitOrAssign for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26061    #[inline]
26062    fn bitor_assign(&mut self, rhs: Self) {
26063        self.0 |= rhs.0;
26064    }
26065}
26066impl core::ops::BitAnd for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26067    type Output = Self;
26068    #[inline]
26069    fn bitand(self, rhs: Self) -> Self {
26070        Self(self.0 & rhs.0)
26071    }
26072}
26073impl core::ops::BitAndAssign for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26074    #[inline]
26075    fn bitand_assign(&mut self, rhs: Self) {
26076        self.0 &= rhs.0;
26077    }
26078}
26079impl core::ops::BitXor for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26080    type Output = Self;
26081    #[inline]
26082    fn bitxor(self, rhs: Self) -> Self {
26083        Self(self.0 ^ rhs.0)
26084    }
26085}
26086impl core::ops::BitXorAssign for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26087    #[inline]
26088    fn bitxor_assign(&mut self, rhs: Self) {
26089        self.0 ^= rhs.0;
26090    }
26091}
26092impl core::ops::Not for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26093    type Output = Self;
26094    #[inline]
26095    fn not(self) -> Self {
26096        Self(!self.0)
26097    }
26098}
26099impl core::fmt::Debug for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
26100    #[allow(unused_mut, unused_variables)]
26101    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26102        let mut first = true;
26103        let mut remaining = self.0;
26104        if remaining & Self::COSITED_EVEN_BIT.0 != 0 {
26105            if !first {
26106                f.write_str(" | ")?;
26107            }
26108            f.write_str("COSITED_EVEN_BIT")?;
26109            remaining &= !Self::COSITED_EVEN_BIT.0;
26110            first = false;
26111        }
26112        if remaining & Self::MIDPOINT_BIT.0 != 0 {
26113            if !first {
26114                f.write_str(" | ")?;
26115            }
26116            f.write_str("MIDPOINT_BIT")?;
26117            remaining &= !Self::MIDPOINT_BIT.0;
26118            first = false;
26119        }
26120        if remaining != 0u32 {
26121            if !first {
26122                f.write_str(" | ")?;
26123            }
26124            write!(f, "{:#x}", remaining)?;
26125        } else if first {
26126            f.write_str("(empty)")?;
26127        }
26128        Ok(())
26129    }
26130}
26131///[`VkVideoEncodeRgbModelConversionFlagBitsVALVE`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbModelConversionFlagBitsVALVE.html)
26132#[repr(transparent)]
26133#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
26134#[doc(alias = "VkVideoEncodeRgbModelConversionFlagBitsVALVE")]
26135pub struct VideoEncodeRgbModelConversionFlagBitsVALVE(u32);
26136impl VideoEncodeRgbModelConversionFlagBitsVALVE {
26137    #[inline]
26138    pub const fn empty() -> Self {
26139        Self(0u32)
26140    }
26141    #[inline]
26142    pub const fn from_raw(value: u32) -> Self {
26143        Self(value)
26144    }
26145    #[inline]
26146    pub const fn as_raw(self) -> u32 {
26147        self.0
26148    }
26149    #[inline]
26150    pub const fn is_empty(self) -> bool {
26151        self.0 == 0u32
26152    }
26153    #[inline]
26154    pub const fn contains(self, other: Self) -> bool {
26155        (self.0 & other.0) == other.0
26156    }
26157    #[inline]
26158    pub const fn all() -> Self {
26159        Self(31u32)
26160    }
26161    ///Bit 0.
26162    pub const RGB_IDENTITY_BIT: Self = Self(1u32);
26163    ///Bit 1.
26164    pub const YCBCR_IDENTITY_BIT: Self = Self(2u32);
26165    ///Bit 2.
26166    pub const YCBCR_709_BIT: Self = Self(4u32);
26167    ///Bit 3.
26168    pub const YCBCR_601_BIT: Self = Self(8u32);
26169    ///Bit 4.
26170    pub const YCBCR_2020_BIT: Self = Self(16u32);
26171}
26172impl core::ops::BitOr for VideoEncodeRgbModelConversionFlagBitsVALVE {
26173    type Output = Self;
26174    #[inline]
26175    fn bitor(self, rhs: Self) -> Self {
26176        Self(self.0 | rhs.0)
26177    }
26178}
26179impl core::ops::BitOrAssign for VideoEncodeRgbModelConversionFlagBitsVALVE {
26180    #[inline]
26181    fn bitor_assign(&mut self, rhs: Self) {
26182        self.0 |= rhs.0;
26183    }
26184}
26185impl core::ops::BitAnd for VideoEncodeRgbModelConversionFlagBitsVALVE {
26186    type Output = Self;
26187    #[inline]
26188    fn bitand(self, rhs: Self) -> Self {
26189        Self(self.0 & rhs.0)
26190    }
26191}
26192impl core::ops::BitAndAssign for VideoEncodeRgbModelConversionFlagBitsVALVE {
26193    #[inline]
26194    fn bitand_assign(&mut self, rhs: Self) {
26195        self.0 &= rhs.0;
26196    }
26197}
26198impl core::ops::BitXor for VideoEncodeRgbModelConversionFlagBitsVALVE {
26199    type Output = Self;
26200    #[inline]
26201    fn bitxor(self, rhs: Self) -> Self {
26202        Self(self.0 ^ rhs.0)
26203    }
26204}
26205impl core::ops::BitXorAssign for VideoEncodeRgbModelConversionFlagBitsVALVE {
26206    #[inline]
26207    fn bitxor_assign(&mut self, rhs: Self) {
26208        self.0 ^= rhs.0;
26209    }
26210}
26211impl core::ops::Not for VideoEncodeRgbModelConversionFlagBitsVALVE {
26212    type Output = Self;
26213    #[inline]
26214    fn not(self) -> Self {
26215        Self(!self.0)
26216    }
26217}
26218impl core::fmt::Debug for VideoEncodeRgbModelConversionFlagBitsVALVE {
26219    #[allow(unused_mut, unused_variables)]
26220    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26221        let mut first = true;
26222        let mut remaining = self.0;
26223        if remaining & Self::RGB_IDENTITY_BIT.0 != 0 {
26224            if !first {
26225                f.write_str(" | ")?;
26226            }
26227            f.write_str("RGB_IDENTITY_BIT")?;
26228            remaining &= !Self::RGB_IDENTITY_BIT.0;
26229            first = false;
26230        }
26231        if remaining & Self::YCBCR_IDENTITY_BIT.0 != 0 {
26232            if !first {
26233                f.write_str(" | ")?;
26234            }
26235            f.write_str("YCBCR_IDENTITY_BIT")?;
26236            remaining &= !Self::YCBCR_IDENTITY_BIT.0;
26237            first = false;
26238        }
26239        if remaining & Self::YCBCR_709_BIT.0 != 0 {
26240            if !first {
26241                f.write_str(" | ")?;
26242            }
26243            f.write_str("YCBCR_709_BIT")?;
26244            remaining &= !Self::YCBCR_709_BIT.0;
26245            first = false;
26246        }
26247        if remaining & Self::YCBCR_601_BIT.0 != 0 {
26248            if !first {
26249                f.write_str(" | ")?;
26250            }
26251            f.write_str("YCBCR_601_BIT")?;
26252            remaining &= !Self::YCBCR_601_BIT.0;
26253            first = false;
26254        }
26255        if remaining & Self::YCBCR_2020_BIT.0 != 0 {
26256            if !first {
26257                f.write_str(" | ")?;
26258            }
26259            f.write_str("YCBCR_2020_BIT")?;
26260            remaining &= !Self::YCBCR_2020_BIT.0;
26261            first = false;
26262        }
26263        if remaining != 0u32 {
26264            if !first {
26265                f.write_str(" | ")?;
26266            }
26267            write!(f, "{:#x}", remaining)?;
26268        } else if first {
26269            f.write_str("(empty)")?;
26270        }
26271        Ok(())
26272    }
26273}
26274///[`VkVideoEncodeRgbRangeCompressionFlagBitsVALVE`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbRangeCompressionFlagBitsVALVE.html)
26275#[repr(transparent)]
26276#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
26277#[doc(alias = "VkVideoEncodeRgbRangeCompressionFlagBitsVALVE")]
26278pub struct VideoEncodeRgbRangeCompressionFlagBitsVALVE(u32);
26279impl VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26280    #[inline]
26281    pub const fn empty() -> Self {
26282        Self(0u32)
26283    }
26284    #[inline]
26285    pub const fn from_raw(value: u32) -> Self {
26286        Self(value)
26287    }
26288    #[inline]
26289    pub const fn as_raw(self) -> u32 {
26290        self.0
26291    }
26292    #[inline]
26293    pub const fn is_empty(self) -> bool {
26294        self.0 == 0u32
26295    }
26296    #[inline]
26297    pub const fn contains(self, other: Self) -> bool {
26298        (self.0 & other.0) == other.0
26299    }
26300    #[inline]
26301    pub const fn all() -> Self {
26302        Self(3u32)
26303    }
26304    ///Bit 0.
26305    pub const FULL_RANGE_BIT: Self = Self(1u32);
26306    ///Bit 1.
26307    pub const NARROW_RANGE_BIT: Self = Self(2u32);
26308}
26309impl core::ops::BitOr for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26310    type Output = Self;
26311    #[inline]
26312    fn bitor(self, rhs: Self) -> Self {
26313        Self(self.0 | rhs.0)
26314    }
26315}
26316impl core::ops::BitOrAssign for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26317    #[inline]
26318    fn bitor_assign(&mut self, rhs: Self) {
26319        self.0 |= rhs.0;
26320    }
26321}
26322impl core::ops::BitAnd for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26323    type Output = Self;
26324    #[inline]
26325    fn bitand(self, rhs: Self) -> Self {
26326        Self(self.0 & rhs.0)
26327    }
26328}
26329impl core::ops::BitAndAssign for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26330    #[inline]
26331    fn bitand_assign(&mut self, rhs: Self) {
26332        self.0 &= rhs.0;
26333    }
26334}
26335impl core::ops::BitXor for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26336    type Output = Self;
26337    #[inline]
26338    fn bitxor(self, rhs: Self) -> Self {
26339        Self(self.0 ^ rhs.0)
26340    }
26341}
26342impl core::ops::BitXorAssign for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26343    #[inline]
26344    fn bitxor_assign(&mut self, rhs: Self) {
26345        self.0 ^= rhs.0;
26346    }
26347}
26348impl core::ops::Not for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26349    type Output = Self;
26350    #[inline]
26351    fn not(self) -> Self {
26352        Self(!self.0)
26353    }
26354}
26355impl core::fmt::Debug for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
26356    #[allow(unused_mut, unused_variables)]
26357    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26358        let mut first = true;
26359        let mut remaining = self.0;
26360        if remaining & Self::FULL_RANGE_BIT.0 != 0 {
26361            if !first {
26362                f.write_str(" | ")?;
26363            }
26364            f.write_str("FULL_RANGE_BIT")?;
26365            remaining &= !Self::FULL_RANGE_BIT.0;
26366            first = false;
26367        }
26368        if remaining & Self::NARROW_RANGE_BIT.0 != 0 {
26369            if !first {
26370                f.write_str(" | ")?;
26371            }
26372            f.write_str("NARROW_RANGE_BIT")?;
26373            remaining &= !Self::NARROW_RANGE_BIT.0;
26374            first = false;
26375        }
26376        if remaining != 0u32 {
26377            if !first {
26378                f.write_str(" | ")?;
26379            }
26380            write!(f, "{:#x}", remaining)?;
26381        } else if first {
26382            f.write_str("(empty)")?;
26383        }
26384        Ok(())
26385    }
26386}
26387///[`VkVideoEncodeUsageFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeUsageFlagBitsKHR.html)
26388#[repr(transparent)]
26389#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
26390#[doc(alias = "VkVideoEncodeUsageFlagBitsKHR")]
26391pub struct VideoEncodeUsageFlagBitsKHR(u32);
26392impl VideoEncodeUsageFlagBitsKHR {
26393    #[inline]
26394    pub const fn empty() -> Self {
26395        Self(0u32)
26396    }
26397    #[inline]
26398    pub const fn from_raw(value: u32) -> Self {
26399        Self(value)
26400    }
26401    #[inline]
26402    pub const fn as_raw(self) -> u32 {
26403        self.0
26404    }
26405    #[inline]
26406    pub const fn is_empty(self) -> bool {
26407        self.0 == 0u32
26408    }
26409    #[inline]
26410    pub const fn contains(self, other: Self) -> bool {
26411        (self.0 & other.0) == other.0
26412    }
26413    #[inline]
26414    pub const fn all() -> Self {
26415        Self(15u32)
26416    }
26417    pub const DEFAULT: Self = Self(0u32);
26418    ///Bit 0.
26419    pub const TRANSCODING: Self = Self(1u32);
26420    ///Bit 1.
26421    pub const STREAMING: Self = Self(2u32);
26422    ///Bit 2.
26423    pub const RECORDING: Self = Self(4u32);
26424    ///Bit 3.
26425    pub const CONFERENCING: Self = Self(8u32);
26426}
26427impl core::ops::BitOr for VideoEncodeUsageFlagBitsKHR {
26428    type Output = Self;
26429    #[inline]
26430    fn bitor(self, rhs: Self) -> Self {
26431        Self(self.0 | rhs.0)
26432    }
26433}
26434impl core::ops::BitOrAssign for VideoEncodeUsageFlagBitsKHR {
26435    #[inline]
26436    fn bitor_assign(&mut self, rhs: Self) {
26437        self.0 |= rhs.0;
26438    }
26439}
26440impl core::ops::BitAnd for VideoEncodeUsageFlagBitsKHR {
26441    type Output = Self;
26442    #[inline]
26443    fn bitand(self, rhs: Self) -> Self {
26444        Self(self.0 & rhs.0)
26445    }
26446}
26447impl core::ops::BitAndAssign for VideoEncodeUsageFlagBitsKHR {
26448    #[inline]
26449    fn bitand_assign(&mut self, rhs: Self) {
26450        self.0 &= rhs.0;
26451    }
26452}
26453impl core::ops::BitXor for VideoEncodeUsageFlagBitsKHR {
26454    type Output = Self;
26455    #[inline]
26456    fn bitxor(self, rhs: Self) -> Self {
26457        Self(self.0 ^ rhs.0)
26458    }
26459}
26460impl core::ops::BitXorAssign for VideoEncodeUsageFlagBitsKHR {
26461    #[inline]
26462    fn bitxor_assign(&mut self, rhs: Self) {
26463        self.0 ^= rhs.0;
26464    }
26465}
26466impl core::ops::Not for VideoEncodeUsageFlagBitsKHR {
26467    type Output = Self;
26468    #[inline]
26469    fn not(self) -> Self {
26470        Self(!self.0)
26471    }
26472}
26473impl core::fmt::Debug for VideoEncodeUsageFlagBitsKHR {
26474    #[allow(unused_mut, unused_variables)]
26475    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26476        let mut first = true;
26477        let mut remaining = self.0;
26478        if remaining & Self::TRANSCODING.0 != 0 {
26479            if !first {
26480                f.write_str(" | ")?;
26481            }
26482            f.write_str("TRANSCODING")?;
26483            remaining &= !Self::TRANSCODING.0;
26484            first = false;
26485        }
26486        if remaining & Self::STREAMING.0 != 0 {
26487            if !first {
26488                f.write_str(" | ")?;
26489            }
26490            f.write_str("STREAMING")?;
26491            remaining &= !Self::STREAMING.0;
26492            first = false;
26493        }
26494        if remaining & Self::RECORDING.0 != 0 {
26495            if !first {
26496                f.write_str(" | ")?;
26497            }
26498            f.write_str("RECORDING")?;
26499            remaining &= !Self::RECORDING.0;
26500            first = false;
26501        }
26502        if remaining & Self::CONFERENCING.0 != 0 {
26503            if !first {
26504                f.write_str(" | ")?;
26505            }
26506            f.write_str("CONFERENCING")?;
26507            remaining &= !Self::CONFERENCING.0;
26508            first = false;
26509        }
26510        if remaining != 0u32 {
26511            if !first {
26512                f.write_str(" | ")?;
26513            }
26514            write!(f, "{:#x}", remaining)?;
26515        } else if first {
26516            f.write_str("(empty)")?;
26517        }
26518        Ok(())
26519    }
26520}
26521///[`VkVideoSessionCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionCreateFlagBitsKHR.html)
26522#[repr(transparent)]
26523#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
26524#[doc(alias = "VkVideoSessionCreateFlagBitsKHR")]
26525pub struct VideoSessionCreateFlagBitsKHR(u32);
26526impl VideoSessionCreateFlagBitsKHR {
26527    #[inline]
26528    pub const fn empty() -> Self {
26529        Self(0u32)
26530    }
26531    #[inline]
26532    pub const fn from_raw(value: u32) -> Self {
26533        Self(value)
26534    }
26535    #[inline]
26536    pub const fn as_raw(self) -> u32 {
26537        self.0
26538    }
26539    #[inline]
26540    pub const fn is_empty(self) -> bool {
26541        self.0 == 0u32
26542    }
26543    #[inline]
26544    pub const fn contains(self, other: Self) -> bool {
26545        (self.0 & other.0) == other.0
26546    }
26547    #[inline]
26548    pub const fn all() -> Self {
26549        Self(63u32)
26550    }
26551    ///Bit 0.
26552    pub const PROTECTED_CONTENT: Self = Self(1u32);
26553    ///Bit 1.
26554    pub const ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS: Self = Self(2u32);
26555    ///Bit 2.
26556    pub const INLINE_QUERIES: Self = Self(4u32);
26557    ///Bit 3.
26558    pub const ALLOW_ENCODE_QUANTIZATION_DELTA_MAP: Self = Self(8u32);
26559    ///Bit 4.
26560    pub const ALLOW_ENCODE_EMPHASIS_MAP: Self = Self(16u32);
26561    ///Bit 5.
26562    pub const INLINE_SESSION_PARAMETERS: Self = Self(32u32);
26563}
26564impl core::ops::BitOr for VideoSessionCreateFlagBitsKHR {
26565    type Output = Self;
26566    #[inline]
26567    fn bitor(self, rhs: Self) -> Self {
26568        Self(self.0 | rhs.0)
26569    }
26570}
26571impl core::ops::BitOrAssign for VideoSessionCreateFlagBitsKHR {
26572    #[inline]
26573    fn bitor_assign(&mut self, rhs: Self) {
26574        self.0 |= rhs.0;
26575    }
26576}
26577impl core::ops::BitAnd for VideoSessionCreateFlagBitsKHR {
26578    type Output = Self;
26579    #[inline]
26580    fn bitand(self, rhs: Self) -> Self {
26581        Self(self.0 & rhs.0)
26582    }
26583}
26584impl core::ops::BitAndAssign for VideoSessionCreateFlagBitsKHR {
26585    #[inline]
26586    fn bitand_assign(&mut self, rhs: Self) {
26587        self.0 &= rhs.0;
26588    }
26589}
26590impl core::ops::BitXor for VideoSessionCreateFlagBitsKHR {
26591    type Output = Self;
26592    #[inline]
26593    fn bitxor(self, rhs: Self) -> Self {
26594        Self(self.0 ^ rhs.0)
26595    }
26596}
26597impl core::ops::BitXorAssign for VideoSessionCreateFlagBitsKHR {
26598    #[inline]
26599    fn bitxor_assign(&mut self, rhs: Self) {
26600        self.0 ^= rhs.0;
26601    }
26602}
26603impl core::ops::Not for VideoSessionCreateFlagBitsKHR {
26604    type Output = Self;
26605    #[inline]
26606    fn not(self) -> Self {
26607        Self(!self.0)
26608    }
26609}
26610impl core::fmt::Debug for VideoSessionCreateFlagBitsKHR {
26611    #[allow(unused_mut, unused_variables)]
26612    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26613        let mut first = true;
26614        let mut remaining = self.0;
26615        if remaining & Self::PROTECTED_CONTENT.0 != 0 {
26616            if !first {
26617                f.write_str(" | ")?;
26618            }
26619            f.write_str("PROTECTED_CONTENT")?;
26620            remaining &= !Self::PROTECTED_CONTENT.0;
26621            first = false;
26622        }
26623        if remaining & Self::ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS.0 != 0 {
26624            if !first {
26625                f.write_str(" | ")?;
26626            }
26627            f.write_str("ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS")?;
26628            remaining &= !Self::ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS.0;
26629            first = false;
26630        }
26631        if remaining & Self::INLINE_QUERIES.0 != 0 {
26632            if !first {
26633                f.write_str(" | ")?;
26634            }
26635            f.write_str("INLINE_QUERIES")?;
26636            remaining &= !Self::INLINE_QUERIES.0;
26637            first = false;
26638        }
26639        if remaining & Self::ALLOW_ENCODE_QUANTIZATION_DELTA_MAP.0 != 0 {
26640            if !first {
26641                f.write_str(" | ")?;
26642            }
26643            f.write_str("ALLOW_ENCODE_QUANTIZATION_DELTA_MAP")?;
26644            remaining &= !Self::ALLOW_ENCODE_QUANTIZATION_DELTA_MAP.0;
26645            first = false;
26646        }
26647        if remaining & Self::ALLOW_ENCODE_EMPHASIS_MAP.0 != 0 {
26648            if !first {
26649                f.write_str(" | ")?;
26650            }
26651            f.write_str("ALLOW_ENCODE_EMPHASIS_MAP")?;
26652            remaining &= !Self::ALLOW_ENCODE_EMPHASIS_MAP.0;
26653            first = false;
26654        }
26655        if remaining & Self::INLINE_SESSION_PARAMETERS.0 != 0 {
26656            if !first {
26657                f.write_str(" | ")?;
26658            }
26659            f.write_str("INLINE_SESSION_PARAMETERS")?;
26660            remaining &= !Self::INLINE_SESSION_PARAMETERS.0;
26661            first = false;
26662        }
26663        if remaining != 0u32 {
26664            if !first {
26665                f.write_str(" | ")?;
26666            }
26667            write!(f, "{:#x}", remaining)?;
26668        } else if first {
26669            f.write_str("(empty)")?;
26670        }
26671        Ok(())
26672    }
26673}
26674///[`VkVideoSessionParametersCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateFlagBitsKHR.html)
26675#[repr(transparent)]
26676#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
26677#[doc(alias = "VkVideoSessionParametersCreateFlagBitsKHR")]
26678pub struct VideoSessionParametersCreateFlagBitsKHR(u32);
26679impl VideoSessionParametersCreateFlagBitsKHR {
26680    #[inline]
26681    pub const fn empty() -> Self {
26682        Self(0u32)
26683    }
26684    #[inline]
26685    pub const fn from_raw(value: u32) -> Self {
26686        Self(value)
26687    }
26688    #[inline]
26689    pub const fn as_raw(self) -> u32 {
26690        self.0
26691    }
26692    #[inline]
26693    pub const fn is_empty(self) -> bool {
26694        self.0 == 0u32
26695    }
26696    #[inline]
26697    pub const fn contains(self, other: Self) -> bool {
26698        (self.0 & other.0) == other.0
26699    }
26700    #[inline]
26701    pub const fn all() -> Self {
26702        Self(1u32)
26703    }
26704    ///Bit 0.
26705    pub const QUANTIZATION_MAP_COMPATIBLE: Self = Self(1u32);
26706}
26707impl core::ops::BitOr for VideoSessionParametersCreateFlagBitsKHR {
26708    type Output = Self;
26709    #[inline]
26710    fn bitor(self, rhs: Self) -> Self {
26711        Self(self.0 | rhs.0)
26712    }
26713}
26714impl core::ops::BitOrAssign for VideoSessionParametersCreateFlagBitsKHR {
26715    #[inline]
26716    fn bitor_assign(&mut self, rhs: Self) {
26717        self.0 |= rhs.0;
26718    }
26719}
26720impl core::ops::BitAnd for VideoSessionParametersCreateFlagBitsKHR {
26721    type Output = Self;
26722    #[inline]
26723    fn bitand(self, rhs: Self) -> Self {
26724        Self(self.0 & rhs.0)
26725    }
26726}
26727impl core::ops::BitAndAssign for VideoSessionParametersCreateFlagBitsKHR {
26728    #[inline]
26729    fn bitand_assign(&mut self, rhs: Self) {
26730        self.0 &= rhs.0;
26731    }
26732}
26733impl core::ops::BitXor for VideoSessionParametersCreateFlagBitsKHR {
26734    type Output = Self;
26735    #[inline]
26736    fn bitxor(self, rhs: Self) -> Self {
26737        Self(self.0 ^ rhs.0)
26738    }
26739}
26740impl core::ops::BitXorAssign for VideoSessionParametersCreateFlagBitsKHR {
26741    #[inline]
26742    fn bitxor_assign(&mut self, rhs: Self) {
26743        self.0 ^= rhs.0;
26744    }
26745}
26746impl core::ops::Not for VideoSessionParametersCreateFlagBitsKHR {
26747    type Output = Self;
26748    #[inline]
26749    fn not(self) -> Self {
26750        Self(!self.0)
26751    }
26752}
26753impl core::fmt::Debug for VideoSessionParametersCreateFlagBitsKHR {
26754    #[allow(unused_mut, unused_variables)]
26755    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26756        let mut first = true;
26757        let mut remaining = self.0;
26758        if remaining & Self::QUANTIZATION_MAP_COMPATIBLE.0 != 0 {
26759            if !first {
26760                f.write_str(" | ")?;
26761            }
26762            f.write_str("QUANTIZATION_MAP_COMPATIBLE")?;
26763            remaining &= !Self::QUANTIZATION_MAP_COMPATIBLE.0;
26764            first = false;
26765        }
26766        if remaining != 0u32 {
26767            if !first {
26768                f.write_str(" | ")?;
26769            }
26770            write!(f, "{:#x}", remaining)?;
26771        } else if first {
26772            f.write_str("(empty)")?;
26773        }
26774        Ok(())
26775    }
26776}
26777///[`VkWaylandSurfaceCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkWaylandSurfaceCreateFlagBitsKHR.html)
26778#[repr(transparent)]
26779#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
26780#[doc(alias = "VkWaylandSurfaceCreateFlagBitsKHR")]
26781pub struct WaylandSurfaceCreateFlagBitsKHR(u32);
26782impl WaylandSurfaceCreateFlagBitsKHR {
26783    #[inline]
26784    pub const fn empty() -> Self {
26785        Self(0u32)
26786    }
26787    #[inline]
26788    pub const fn from_raw(value: u32) -> Self {
26789        Self(value)
26790    }
26791    #[inline]
26792    pub const fn as_raw(self) -> u32 {
26793        self.0
26794    }
26795    #[inline]
26796    pub const fn is_empty(self) -> bool {
26797        self.0 == 0u32
26798    }
26799    #[inline]
26800    pub const fn contains(self, other: Self) -> bool {
26801        (self.0 & other.0) == other.0
26802    }
26803    #[inline]
26804    pub const fn all() -> Self {
26805        Self(0u32)
26806    }
26807}
26808impl core::ops::BitOr for WaylandSurfaceCreateFlagBitsKHR {
26809    type Output = Self;
26810    #[inline]
26811    fn bitor(self, rhs: Self) -> Self {
26812        Self(self.0 | rhs.0)
26813    }
26814}
26815impl core::ops::BitOrAssign for WaylandSurfaceCreateFlagBitsKHR {
26816    #[inline]
26817    fn bitor_assign(&mut self, rhs: Self) {
26818        self.0 |= rhs.0;
26819    }
26820}
26821impl core::ops::BitAnd for WaylandSurfaceCreateFlagBitsKHR {
26822    type Output = Self;
26823    #[inline]
26824    fn bitand(self, rhs: Self) -> Self {
26825        Self(self.0 & rhs.0)
26826    }
26827}
26828impl core::ops::BitAndAssign for WaylandSurfaceCreateFlagBitsKHR {
26829    #[inline]
26830    fn bitand_assign(&mut self, rhs: Self) {
26831        self.0 &= rhs.0;
26832    }
26833}
26834impl core::ops::BitXor for WaylandSurfaceCreateFlagBitsKHR {
26835    type Output = Self;
26836    #[inline]
26837    fn bitxor(self, rhs: Self) -> Self {
26838        Self(self.0 ^ rhs.0)
26839    }
26840}
26841impl core::ops::BitXorAssign for WaylandSurfaceCreateFlagBitsKHR {
26842    #[inline]
26843    fn bitxor_assign(&mut self, rhs: Self) {
26844        self.0 ^= rhs.0;
26845    }
26846}
26847impl core::ops::Not for WaylandSurfaceCreateFlagBitsKHR {
26848    type Output = Self;
26849    #[inline]
26850    fn not(self) -> Self {
26851        Self(!self.0)
26852    }
26853}
26854impl core::fmt::Debug for WaylandSurfaceCreateFlagBitsKHR {
26855    #[allow(unused_mut, unused_variables)]
26856    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26857        let mut first = true;
26858        let mut remaining = self.0;
26859        if remaining != 0u32 {
26860            if !first {
26861                f.write_str(" | ")?;
26862            }
26863            write!(f, "{:#x}", remaining)?;
26864        } else if first {
26865            f.write_str("(empty)")?;
26866        }
26867        Ok(())
26868    }
26869}
vulkan_rust_sys/bitmasks.rs

vulkan_rust_sys/
bitmasks.rs
