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, 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    ///Bit 0.
28    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(1u32);
29    ///Bit 3.
30    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self(8u32);
31    ///Bit 2.
32    pub const MOTION: Self = Self(4u32);
33}
34impl core::ops::BitOr for AccelerationStructureCreateFlagBitsKHR {
35    type Output = Self;
36    #[inline]
37    fn bitor(self, rhs: Self) -> Self {
38        Self(self.0 | rhs.0)
39    }
40}
41impl core::ops::BitOrAssign for AccelerationStructureCreateFlagBitsKHR {
42    #[inline]
43    fn bitor_assign(&mut self, rhs: Self) {
44        self.0 |= rhs.0;
45    }
46}
47impl core::ops::BitAnd for AccelerationStructureCreateFlagBitsKHR {
48    type Output = Self;
49    #[inline]
50    fn bitand(self, rhs: Self) -> Self {
51        Self(self.0 & rhs.0)
52    }
53}
54impl core::ops::BitAndAssign for AccelerationStructureCreateFlagBitsKHR {
55    #[inline]
56    fn bitand_assign(&mut self, rhs: Self) {
57        self.0 &= rhs.0;
58    }
59}
60impl core::ops::BitXor for AccelerationStructureCreateFlagBitsKHR {
61    type Output = Self;
62    #[inline]
63    fn bitxor(self, rhs: Self) -> Self {
64        Self(self.0 ^ rhs.0)
65    }
66}
67impl core::ops::BitXorAssign for AccelerationStructureCreateFlagBitsKHR {
68    #[inline]
69    fn bitxor_assign(&mut self, rhs: Self) {
70        self.0 ^= rhs.0;
71    }
72}
73impl core::ops::Not for AccelerationStructureCreateFlagBitsKHR {
74    type Output = Self;
75    #[inline]
76    fn not(self) -> Self {
77        Self(!self.0)
78    }
79}
80impl core::fmt::Debug for AccelerationStructureCreateFlagBitsKHR {
81    #[allow(unused_mut, unused_variables)]
82    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
83        let mut first = true;
84        let mut remaining = self.0;
85        if remaining & Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0 != 0 {
86            if !first {
87                f.write_str(" | ")?;
88            }
89            f.write_str("DEVICE_ADDRESS_CAPTURE_REPLAY")?;
90            remaining &= !Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0;
91            first = false;
92        }
93        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0 != 0 {
94            if !first {
95                f.write_str(" | ")?;
96            }
97            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY")?;
98            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0;
99            first = false;
100        }
101        if remaining & Self::MOTION.0 != 0 {
102            if !first {
103                f.write_str(" | ")?;
104            }
105            f.write_str("MOTION")?;
106            remaining &= !Self::MOTION.0;
107            first = false;
108        }
109        if remaining != 0u32 {
110            if !first {
111                f.write_str(" | ")?;
112            }
113            write!(f, "{:#x}", remaining)?;
114        } else if first {
115            f.write_str("(empty)")?;
116        }
117        Ok(())
118    }
119}
120///[`VkAccessFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits.html)
121#[repr(transparent)]
122#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
123#[doc(alias = "VkAccessFlagBits")]
124pub struct AccessFlagBits(u32);
125impl AccessFlagBits {
126    #[inline]
127    pub const fn empty() -> Self {
128        Self(0u32)
129    }
130    #[inline]
131    pub const fn from_raw(value: u32) -> Self {
132        Self(value)
133    }
134    #[inline]
135    pub const fn as_raw(self) -> u32 {
136        self.0
137    }
138    #[inline]
139    pub const fn is_empty(self) -> bool {
140        self.0 == 0u32
141    }
142    #[inline]
143    pub const fn contains(self, other: Self) -> bool {
144        (self.0 & other.0) == other.0
145    }
146    ///Bit 0.
147    pub const INDIRECT_COMMAND_READ: Self = Self(1u32);
148    ///Bit 1.
149    pub const INDEX_READ: Self = Self(2u32);
150    ///Bit 2.
151    pub const VERTEX_ATTRIBUTE_READ: Self = Self(4u32);
152    ///Bit 3.
153    pub const UNIFORM_READ: Self = Self(8u32);
154    ///Bit 4.
155    pub const INPUT_ATTACHMENT_READ: Self = Self(16u32);
156    ///Bit 5.
157    pub const SHADER_READ: Self = Self(32u32);
158    ///Bit 6.
159    pub const SHADER_WRITE: Self = Self(64u32);
160    ///Bit 7.
161    pub const COLOR_ATTACHMENT_READ: Self = Self(128u32);
162    ///Bit 8.
163    pub const COLOR_ATTACHMENT_WRITE: Self = Self(256u32);
164    ///Bit 9.
165    pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(512u32);
166    ///Bit 10.
167    pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(1024u32);
168    ///Bit 11.
169    pub const TRANSFER_READ: Self = Self(2048u32);
170    ///Bit 12.
171    pub const TRANSFER_WRITE: Self = Self(4096u32);
172    ///Bit 13.
173    pub const HOST_READ: Self = Self(8192u32);
174    ///Bit 14.
175    pub const HOST_WRITE: Self = Self(16384u32);
176    ///Bit 15.
177    pub const MEMORY_READ: Self = Self(32768u32);
178    ///Bit 16.
179    pub const MEMORY_WRITE: Self = Self(65536u32);
180    pub const NONE: Self = Self(0u32);
181    ///Bit 25.
182    pub const TRANSFORM_FEEDBACK_WRITE: Self = Self(33554432u32);
183    ///Bit 26.
184    pub const TRANSFORM_FEEDBACK_COUNTER_READ: Self = Self(67108864u32);
185    ///Bit 27.
186    pub const TRANSFORM_FEEDBACK_COUNTER_WRITE: Self = Self(134217728u32);
187    ///Bit 20.
188    pub const CONDITIONAL_RENDERING_READ: Self = Self(1048576u32);
189    ///Bit 19.
190    pub const COLOR_ATTACHMENT_READ_NONCOHERENT: Self = Self(524288u32);
191    ///Bit 21.
192    pub const ACCELERATION_STRUCTURE_READ: Self = Self(2097152u32);
193    ///Bit 22.
194    pub const ACCELERATION_STRUCTURE_WRITE: Self = Self(4194304u32);
195    pub const SHADING_RATE_IMAGE_READ: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ;
196    ///Bit 24.
197    pub const FRAGMENT_DENSITY_MAP_READ: Self = Self(16777216u32);
198    ///Bit 23.
199    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ: Self = Self(8388608u32);
200}
201impl core::ops::BitOr for AccessFlagBits {
202    type Output = Self;
203    #[inline]
204    fn bitor(self, rhs: Self) -> Self {
205        Self(self.0 | rhs.0)
206    }
207}
208impl core::ops::BitOrAssign for AccessFlagBits {
209    #[inline]
210    fn bitor_assign(&mut self, rhs: Self) {
211        self.0 |= rhs.0;
212    }
213}
214impl core::ops::BitAnd for AccessFlagBits {
215    type Output = Self;
216    #[inline]
217    fn bitand(self, rhs: Self) -> Self {
218        Self(self.0 & rhs.0)
219    }
220}
221impl core::ops::BitAndAssign for AccessFlagBits {
222    #[inline]
223    fn bitand_assign(&mut self, rhs: Self) {
224        self.0 &= rhs.0;
225    }
226}
227impl core::ops::BitXor for AccessFlagBits {
228    type Output = Self;
229    #[inline]
230    fn bitxor(self, rhs: Self) -> Self {
231        Self(self.0 ^ rhs.0)
232    }
233}
234impl core::ops::BitXorAssign for AccessFlagBits {
235    #[inline]
236    fn bitxor_assign(&mut self, rhs: Self) {
237        self.0 ^= rhs.0;
238    }
239}
240impl core::ops::Not for AccessFlagBits {
241    type Output = Self;
242    #[inline]
243    fn not(self) -> Self {
244        Self(!self.0)
245    }
246}
247impl core::fmt::Debug for AccessFlagBits {
248    #[allow(unused_mut, unused_variables)]
249    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
250        let mut first = true;
251        let mut remaining = self.0;
252        if remaining & Self::INDIRECT_COMMAND_READ.0 != 0 {
253            if !first {
254                f.write_str(" | ")?;
255            }
256            f.write_str("INDIRECT_COMMAND_READ")?;
257            remaining &= !Self::INDIRECT_COMMAND_READ.0;
258            first = false;
259        }
260        if remaining & Self::INDEX_READ.0 != 0 {
261            if !first {
262                f.write_str(" | ")?;
263            }
264            f.write_str("INDEX_READ")?;
265            remaining &= !Self::INDEX_READ.0;
266            first = false;
267        }
268        if remaining & Self::VERTEX_ATTRIBUTE_READ.0 != 0 {
269            if !first {
270                f.write_str(" | ")?;
271            }
272            f.write_str("VERTEX_ATTRIBUTE_READ")?;
273            remaining &= !Self::VERTEX_ATTRIBUTE_READ.0;
274            first = false;
275        }
276        if remaining & Self::UNIFORM_READ.0 != 0 {
277            if !first {
278                f.write_str(" | ")?;
279            }
280            f.write_str("UNIFORM_READ")?;
281            remaining &= !Self::UNIFORM_READ.0;
282            first = false;
283        }
284        if remaining & Self::INPUT_ATTACHMENT_READ.0 != 0 {
285            if !first {
286                f.write_str(" | ")?;
287            }
288            f.write_str("INPUT_ATTACHMENT_READ")?;
289            remaining &= !Self::INPUT_ATTACHMENT_READ.0;
290            first = false;
291        }
292        if remaining & Self::SHADER_READ.0 != 0 {
293            if !first {
294                f.write_str(" | ")?;
295            }
296            f.write_str("SHADER_READ")?;
297            remaining &= !Self::SHADER_READ.0;
298            first = false;
299        }
300        if remaining & Self::SHADER_WRITE.0 != 0 {
301            if !first {
302                f.write_str(" | ")?;
303            }
304            f.write_str("SHADER_WRITE")?;
305            remaining &= !Self::SHADER_WRITE.0;
306            first = false;
307        }
308        if remaining & Self::COLOR_ATTACHMENT_READ.0 != 0 {
309            if !first {
310                f.write_str(" | ")?;
311            }
312            f.write_str("COLOR_ATTACHMENT_READ")?;
313            remaining &= !Self::COLOR_ATTACHMENT_READ.0;
314            first = false;
315        }
316        if remaining & Self::COLOR_ATTACHMENT_WRITE.0 != 0 {
317            if !first {
318                f.write_str(" | ")?;
319            }
320            f.write_str("COLOR_ATTACHMENT_WRITE")?;
321            remaining &= !Self::COLOR_ATTACHMENT_WRITE.0;
322            first = false;
323        }
324        if remaining & Self::DEPTH_STENCIL_ATTACHMENT_READ.0 != 0 {
325            if !first {
326                f.write_str(" | ")?;
327            }
328            f.write_str("DEPTH_STENCIL_ATTACHMENT_READ")?;
329            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT_READ.0;
330            first = false;
331        }
332        if remaining & Self::DEPTH_STENCIL_ATTACHMENT_WRITE.0 != 0 {
333            if !first {
334                f.write_str(" | ")?;
335            }
336            f.write_str("DEPTH_STENCIL_ATTACHMENT_WRITE")?;
337            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT_WRITE.0;
338            first = false;
339        }
340        if remaining & Self::TRANSFER_READ.0 != 0 {
341            if !first {
342                f.write_str(" | ")?;
343            }
344            f.write_str("TRANSFER_READ")?;
345            remaining &= !Self::TRANSFER_READ.0;
346            first = false;
347        }
348        if remaining & Self::TRANSFER_WRITE.0 != 0 {
349            if !first {
350                f.write_str(" | ")?;
351            }
352            f.write_str("TRANSFER_WRITE")?;
353            remaining &= !Self::TRANSFER_WRITE.0;
354            first = false;
355        }
356        if remaining & Self::HOST_READ.0 != 0 {
357            if !first {
358                f.write_str(" | ")?;
359            }
360            f.write_str("HOST_READ")?;
361            remaining &= !Self::HOST_READ.0;
362            first = false;
363        }
364        if remaining & Self::HOST_WRITE.0 != 0 {
365            if !first {
366                f.write_str(" | ")?;
367            }
368            f.write_str("HOST_WRITE")?;
369            remaining &= !Self::HOST_WRITE.0;
370            first = false;
371        }
372        if remaining & Self::MEMORY_READ.0 != 0 {
373            if !first {
374                f.write_str(" | ")?;
375            }
376            f.write_str("MEMORY_READ")?;
377            remaining &= !Self::MEMORY_READ.0;
378            first = false;
379        }
380        if remaining & Self::MEMORY_WRITE.0 != 0 {
381            if !first {
382                f.write_str(" | ")?;
383            }
384            f.write_str("MEMORY_WRITE")?;
385            remaining &= !Self::MEMORY_WRITE.0;
386            first = false;
387        }
388        if remaining & Self::TRANSFORM_FEEDBACK_WRITE.0 != 0 {
389            if !first {
390                f.write_str(" | ")?;
391            }
392            f.write_str("TRANSFORM_FEEDBACK_WRITE")?;
393            remaining &= !Self::TRANSFORM_FEEDBACK_WRITE.0;
394            first = false;
395        }
396        if remaining & Self::TRANSFORM_FEEDBACK_COUNTER_READ.0 != 0 {
397            if !first {
398                f.write_str(" | ")?;
399            }
400            f.write_str("TRANSFORM_FEEDBACK_COUNTER_READ")?;
401            remaining &= !Self::TRANSFORM_FEEDBACK_COUNTER_READ.0;
402            first = false;
403        }
404        if remaining & Self::TRANSFORM_FEEDBACK_COUNTER_WRITE.0 != 0 {
405            if !first {
406                f.write_str(" | ")?;
407            }
408            f.write_str("TRANSFORM_FEEDBACK_COUNTER_WRITE")?;
409            remaining &= !Self::TRANSFORM_FEEDBACK_COUNTER_WRITE.0;
410            first = false;
411        }
412        if remaining & Self::CONDITIONAL_RENDERING_READ.0 != 0 {
413            if !first {
414                f.write_str(" | ")?;
415            }
416            f.write_str("CONDITIONAL_RENDERING_READ")?;
417            remaining &= !Self::CONDITIONAL_RENDERING_READ.0;
418            first = false;
419        }
420        if remaining & Self::COLOR_ATTACHMENT_READ_NONCOHERENT.0 != 0 {
421            if !first {
422                f.write_str(" | ")?;
423            }
424            f.write_str("COLOR_ATTACHMENT_READ_NONCOHERENT")?;
425            remaining &= !Self::COLOR_ATTACHMENT_READ_NONCOHERENT.0;
426            first = false;
427        }
428        if remaining & Self::ACCELERATION_STRUCTURE_READ.0 != 0 {
429            if !first {
430                f.write_str(" | ")?;
431            }
432            f.write_str("ACCELERATION_STRUCTURE_READ")?;
433            remaining &= !Self::ACCELERATION_STRUCTURE_READ.0;
434            first = false;
435        }
436        if remaining & Self::ACCELERATION_STRUCTURE_WRITE.0 != 0 {
437            if !first {
438                f.write_str(" | ")?;
439            }
440            f.write_str("ACCELERATION_STRUCTURE_WRITE")?;
441            remaining &= !Self::ACCELERATION_STRUCTURE_WRITE.0;
442            first = false;
443        }
444        if remaining & Self::FRAGMENT_DENSITY_MAP_READ.0 != 0 {
445            if !first {
446                f.write_str(" | ")?;
447            }
448            f.write_str("FRAGMENT_DENSITY_MAP_READ")?;
449            remaining &= !Self::FRAGMENT_DENSITY_MAP_READ.0;
450            first = false;
451        }
452        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0 != 0 {
453            if !first {
454                f.write_str(" | ")?;
455            }
456            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT_READ")?;
457            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0;
458            first = false;
459        }
460        if remaining != 0u32 {
461            if !first {
462                f.write_str(" | ")?;
463            }
464            write!(f, "{:#x}", remaining)?;
465        } else if first {
466            f.write_str("(empty)")?;
467        }
468        Ok(())
469    }
470}
471///[`VkAccessFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits2.html)
472#[repr(transparent)]
473#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
474#[doc(alias = "VkAccessFlagBits2")]
475pub struct AccessFlagBits2(u64);
476impl AccessFlagBits2 {
477    #[inline]
478    pub const fn empty() -> Self {
479        Self(0u64)
480    }
481    #[inline]
482    pub const fn from_raw(value: u64) -> Self {
483        Self(value)
484    }
485    #[inline]
486    pub const fn as_raw(self) -> u64 {
487        self.0
488    }
489    #[inline]
490    pub const fn is_empty(self) -> bool {
491        self.0 == 0u64
492    }
493    #[inline]
494    pub const fn contains(self, other: Self) -> bool {
495        (self.0 & other.0) == other.0
496    }
497    pub const _2_NONE: Self = Self(0u64);
498    ///Bit 0.
499    pub const _2_INDIRECT_COMMAND_READ: Self = Self(1u64);
500    ///Bit 1.
501    pub const _2_INDEX_READ: Self = Self(2u64);
502    ///Bit 2.
503    pub const _2_VERTEX_ATTRIBUTE_READ: Self = Self(4u64);
504    ///Bit 3.
505    pub const _2_UNIFORM_READ: Self = Self(8u64);
506    ///Bit 4.
507    pub const _2_INPUT_ATTACHMENT_READ: Self = Self(16u64);
508    ///Bit 5.
509    pub const _2_SHADER_READ: Self = Self(32u64);
510    ///Bit 6.
511    pub const _2_SHADER_WRITE: Self = Self(64u64);
512    ///Bit 7.
513    pub const _2_COLOR_ATTACHMENT_READ: Self = Self(128u64);
514    ///Bit 8.
515    pub const _2_COLOR_ATTACHMENT_WRITE: Self = Self(256u64);
516    ///Bit 9.
517    pub const _2_DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(512u64);
518    ///Bit 10.
519    pub const _2_DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(1024u64);
520    ///Bit 11.
521    pub const _2_TRANSFER_READ: Self = Self(2048u64);
522    ///Bit 12.
523    pub const _2_TRANSFER_WRITE: Self = Self(4096u64);
524    ///Bit 13.
525    pub const _2_HOST_READ: Self = Self(8192u64);
526    ///Bit 14.
527    pub const _2_HOST_WRITE: Self = Self(16384u64);
528    ///Bit 15.
529    pub const _2_MEMORY_READ: Self = Self(32768u64);
530    ///Bit 16.
531    pub const _2_MEMORY_WRITE: Self = Self(65536u64);
532    ///Bit 32.
533    pub const _2_SHADER_SAMPLED_READ: Self = Self(4294967296u64);
534    ///Bit 33.
535    pub const _2_SHADER_STORAGE_READ: Self = Self(8589934592u64);
536    ///Bit 34.
537    pub const _2_SHADER_STORAGE_WRITE: Self = Self(17179869184u64);
538    ///Bit 35.
539    pub const _2_VIDEO_DECODE_READ: Self = Self(34359738368u64);
540    ///Bit 36.
541    pub const _2_VIDEO_DECODE_WRITE: Self = Self(68719476736u64);
542    ///Bit 57.
543    pub const _2_SAMPLER_HEAP_READ: Self = Self(144115188075855872u64);
544    ///Bit 58.
545    pub const _2_RESOURCE_HEAP_READ: Self = Self(288230376151711744u64);
546    ///Bit 37.
547    pub const _2_VIDEO_ENCODE_READ: Self = Self(137438953472u64);
548    ///Bit 38.
549    pub const _2_VIDEO_ENCODE_WRITE: Self = Self(274877906944u64);
550    ///Bit 51.
551    pub const _2_SHADER_TILE_ATTACHMENT_READ_BIT: Self = Self(2251799813685248u64);
552    ///Bit 52.
553    pub const _2_SHADER_TILE_ATTACHMENT_WRITE_BIT: Self = Self(4503599627370496u64);
554    ///Bit 25.
555    pub const _2_TRANSFORM_FEEDBACK_WRITE: Self = Self(33554432u64);
556    ///Bit 26.
557    pub const _2_TRANSFORM_FEEDBACK_COUNTER_READ: Self = Self(67108864u64);
558    ///Bit 27.
559    pub const _2_TRANSFORM_FEEDBACK_COUNTER_WRITE: Self = Self(134217728u64);
560    ///Bit 20.
561    pub const _2_CONDITIONAL_RENDERING_READ: Self = Self(1048576u64);
562    ///Bit 23.
563    pub const _2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ: Self = Self(8388608u64);
564    pub const _2_SHADING_RATE_IMAGE_READ: Self = Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ;
565    ///Bit 21.
566    pub const _2_ACCELERATION_STRUCTURE_READ: Self = Self(2097152u64);
567    ///Bit 22.
568    pub const _2_ACCELERATION_STRUCTURE_WRITE: Self = Self(4194304u64);
569    ///Bit 24.
570    pub const _2_FRAGMENT_DENSITY_MAP_READ: Self = Self(16777216u64);
571    ///Bit 19.
572    pub const _2_COLOR_ATTACHMENT_READ_NONCOHERENT: Self = Self(524288u64);
573    ///Bit 41.
574    pub const _2_DESCRIPTOR_BUFFER_READ: Self = Self(2199023255552u64);
575    ///Bit 39.
576    pub const _2_INVOCATION_MASK_READ_BIT: Self = Self(549755813888u64);
577    ///Bit 40.
578    pub const _2_SHADER_BINDING_TABLE_READ: Self = Self(1099511627776u64);
579    ///Bit 44.
580    pub const _2_MICROMAP_READ: Self = Self(17592186044416u64);
581    ///Bit 45.
582    pub const _2_MICROMAP_WRITE: Self = Self(35184372088832u64);
583    ///Bit 42.
584    pub const _2_OPTICAL_FLOW_READ: Self = Self(4398046511104u64);
585    ///Bit 43.
586    pub const _2_OPTICAL_FLOW_WRITE: Self = Self(8796093022208u64);
587    ///Bit 47.
588    pub const _2_DATA_GRAPH_READ_BIT: Self = Self(140737488355328u64);
589    ///Bit 48.
590    pub const _2_DATA_GRAPH_WRITE_BIT: Self = Self(281474976710656u64);
591    ///Bit 55.
592    pub const _2_MEMORY_DECOMPRESSION_READ: Self = Self(36028797018963968u64);
593    ///Bit 56.
594    pub const _2_MEMORY_DECOMPRESSION_WRITE: Self = Self(72057594037927936u64);
595}
596impl core::ops::BitOr for AccessFlagBits2 {
597    type Output = Self;
598    #[inline]
599    fn bitor(self, rhs: Self) -> Self {
600        Self(self.0 | rhs.0)
601    }
602}
603impl core::ops::BitOrAssign for AccessFlagBits2 {
604    #[inline]
605    fn bitor_assign(&mut self, rhs: Self) {
606        self.0 |= rhs.0;
607    }
608}
609impl core::ops::BitAnd for AccessFlagBits2 {
610    type Output = Self;
611    #[inline]
612    fn bitand(self, rhs: Self) -> Self {
613        Self(self.0 & rhs.0)
614    }
615}
616impl core::ops::BitAndAssign for AccessFlagBits2 {
617    #[inline]
618    fn bitand_assign(&mut self, rhs: Self) {
619        self.0 &= rhs.0;
620    }
621}
622impl core::ops::BitXor for AccessFlagBits2 {
623    type Output = Self;
624    #[inline]
625    fn bitxor(self, rhs: Self) -> Self {
626        Self(self.0 ^ rhs.0)
627    }
628}
629impl core::ops::BitXorAssign for AccessFlagBits2 {
630    #[inline]
631    fn bitxor_assign(&mut self, rhs: Self) {
632        self.0 ^= rhs.0;
633    }
634}
635impl core::ops::Not for AccessFlagBits2 {
636    type Output = Self;
637    #[inline]
638    fn not(self) -> Self {
639        Self(!self.0)
640    }
641}
642impl core::fmt::Debug for AccessFlagBits2 {
643    #[allow(unused_mut, unused_variables)]
644    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
645        let mut first = true;
646        let mut remaining = self.0;
647        if remaining & Self::_2_INDIRECT_COMMAND_READ.0 != 0 {
648            if !first {
649                f.write_str(" | ")?;
650            }
651            f.write_str("_2_INDIRECT_COMMAND_READ")?;
652            remaining &= !Self::_2_INDIRECT_COMMAND_READ.0;
653            first = false;
654        }
655        if remaining & Self::_2_INDEX_READ.0 != 0 {
656            if !first {
657                f.write_str(" | ")?;
658            }
659            f.write_str("_2_INDEX_READ")?;
660            remaining &= !Self::_2_INDEX_READ.0;
661            first = false;
662        }
663        if remaining & Self::_2_VERTEX_ATTRIBUTE_READ.0 != 0 {
664            if !first {
665                f.write_str(" | ")?;
666            }
667            f.write_str("_2_VERTEX_ATTRIBUTE_READ")?;
668            remaining &= !Self::_2_VERTEX_ATTRIBUTE_READ.0;
669            first = false;
670        }
671        if remaining & Self::_2_UNIFORM_READ.0 != 0 {
672            if !first {
673                f.write_str(" | ")?;
674            }
675            f.write_str("_2_UNIFORM_READ")?;
676            remaining &= !Self::_2_UNIFORM_READ.0;
677            first = false;
678        }
679        if remaining & Self::_2_INPUT_ATTACHMENT_READ.0 != 0 {
680            if !first {
681                f.write_str(" | ")?;
682            }
683            f.write_str("_2_INPUT_ATTACHMENT_READ")?;
684            remaining &= !Self::_2_INPUT_ATTACHMENT_READ.0;
685            first = false;
686        }
687        if remaining & Self::_2_SHADER_READ.0 != 0 {
688            if !first {
689                f.write_str(" | ")?;
690            }
691            f.write_str("_2_SHADER_READ")?;
692            remaining &= !Self::_2_SHADER_READ.0;
693            first = false;
694        }
695        if remaining & Self::_2_SHADER_WRITE.0 != 0 {
696            if !first {
697                f.write_str(" | ")?;
698            }
699            f.write_str("_2_SHADER_WRITE")?;
700            remaining &= !Self::_2_SHADER_WRITE.0;
701            first = false;
702        }
703        if remaining & Self::_2_COLOR_ATTACHMENT_READ.0 != 0 {
704            if !first {
705                f.write_str(" | ")?;
706            }
707            f.write_str("_2_COLOR_ATTACHMENT_READ")?;
708            remaining &= !Self::_2_COLOR_ATTACHMENT_READ.0;
709            first = false;
710        }
711        if remaining & Self::_2_COLOR_ATTACHMENT_WRITE.0 != 0 {
712            if !first {
713                f.write_str(" | ")?;
714            }
715            f.write_str("_2_COLOR_ATTACHMENT_WRITE")?;
716            remaining &= !Self::_2_COLOR_ATTACHMENT_WRITE.0;
717            first = false;
718        }
719        if remaining & Self::_2_DEPTH_STENCIL_ATTACHMENT_READ.0 != 0 {
720            if !first {
721                f.write_str(" | ")?;
722            }
723            f.write_str("_2_DEPTH_STENCIL_ATTACHMENT_READ")?;
724            remaining &= !Self::_2_DEPTH_STENCIL_ATTACHMENT_READ.0;
725            first = false;
726        }
727        if remaining & Self::_2_DEPTH_STENCIL_ATTACHMENT_WRITE.0 != 0 {
728            if !first {
729                f.write_str(" | ")?;
730            }
731            f.write_str("_2_DEPTH_STENCIL_ATTACHMENT_WRITE")?;
732            remaining &= !Self::_2_DEPTH_STENCIL_ATTACHMENT_WRITE.0;
733            first = false;
734        }
735        if remaining & Self::_2_TRANSFER_READ.0 != 0 {
736            if !first {
737                f.write_str(" | ")?;
738            }
739            f.write_str("_2_TRANSFER_READ")?;
740            remaining &= !Self::_2_TRANSFER_READ.0;
741            first = false;
742        }
743        if remaining & Self::_2_TRANSFER_WRITE.0 != 0 {
744            if !first {
745                f.write_str(" | ")?;
746            }
747            f.write_str("_2_TRANSFER_WRITE")?;
748            remaining &= !Self::_2_TRANSFER_WRITE.0;
749            first = false;
750        }
751        if remaining & Self::_2_HOST_READ.0 != 0 {
752            if !first {
753                f.write_str(" | ")?;
754            }
755            f.write_str("_2_HOST_READ")?;
756            remaining &= !Self::_2_HOST_READ.0;
757            first = false;
758        }
759        if remaining & Self::_2_HOST_WRITE.0 != 0 {
760            if !first {
761                f.write_str(" | ")?;
762            }
763            f.write_str("_2_HOST_WRITE")?;
764            remaining &= !Self::_2_HOST_WRITE.0;
765            first = false;
766        }
767        if remaining & Self::_2_MEMORY_READ.0 != 0 {
768            if !first {
769                f.write_str(" | ")?;
770            }
771            f.write_str("_2_MEMORY_READ")?;
772            remaining &= !Self::_2_MEMORY_READ.0;
773            first = false;
774        }
775        if remaining & Self::_2_MEMORY_WRITE.0 != 0 {
776            if !first {
777                f.write_str(" | ")?;
778            }
779            f.write_str("_2_MEMORY_WRITE")?;
780            remaining &= !Self::_2_MEMORY_WRITE.0;
781            first = false;
782        }
783        if remaining & Self::_2_SHADER_SAMPLED_READ.0 != 0 {
784            if !first {
785                f.write_str(" | ")?;
786            }
787            f.write_str("_2_SHADER_SAMPLED_READ")?;
788            remaining &= !Self::_2_SHADER_SAMPLED_READ.0;
789            first = false;
790        }
791        if remaining & Self::_2_SHADER_STORAGE_READ.0 != 0 {
792            if !first {
793                f.write_str(" | ")?;
794            }
795            f.write_str("_2_SHADER_STORAGE_READ")?;
796            remaining &= !Self::_2_SHADER_STORAGE_READ.0;
797            first = false;
798        }
799        if remaining & Self::_2_SHADER_STORAGE_WRITE.0 != 0 {
800            if !first {
801                f.write_str(" | ")?;
802            }
803            f.write_str("_2_SHADER_STORAGE_WRITE")?;
804            remaining &= !Self::_2_SHADER_STORAGE_WRITE.0;
805            first = false;
806        }
807        if remaining & Self::_2_VIDEO_DECODE_READ.0 != 0 {
808            if !first {
809                f.write_str(" | ")?;
810            }
811            f.write_str("_2_VIDEO_DECODE_READ")?;
812            remaining &= !Self::_2_VIDEO_DECODE_READ.0;
813            first = false;
814        }
815        if remaining & Self::_2_VIDEO_DECODE_WRITE.0 != 0 {
816            if !first {
817                f.write_str(" | ")?;
818            }
819            f.write_str("_2_VIDEO_DECODE_WRITE")?;
820            remaining &= !Self::_2_VIDEO_DECODE_WRITE.0;
821            first = false;
822        }
823        if remaining & Self::_2_SAMPLER_HEAP_READ.0 != 0 {
824            if !first {
825                f.write_str(" | ")?;
826            }
827            f.write_str("_2_SAMPLER_HEAP_READ")?;
828            remaining &= !Self::_2_SAMPLER_HEAP_READ.0;
829            first = false;
830        }
831        if remaining & Self::_2_RESOURCE_HEAP_READ.0 != 0 {
832            if !first {
833                f.write_str(" | ")?;
834            }
835            f.write_str("_2_RESOURCE_HEAP_READ")?;
836            remaining &= !Self::_2_RESOURCE_HEAP_READ.0;
837            first = false;
838        }
839        if remaining & Self::_2_VIDEO_ENCODE_READ.0 != 0 {
840            if !first {
841                f.write_str(" | ")?;
842            }
843            f.write_str("_2_VIDEO_ENCODE_READ")?;
844            remaining &= !Self::_2_VIDEO_ENCODE_READ.0;
845            first = false;
846        }
847        if remaining & Self::_2_VIDEO_ENCODE_WRITE.0 != 0 {
848            if !first {
849                f.write_str(" | ")?;
850            }
851            f.write_str("_2_VIDEO_ENCODE_WRITE")?;
852            remaining &= !Self::_2_VIDEO_ENCODE_WRITE.0;
853            first = false;
854        }
855        if remaining & Self::_2_SHADER_TILE_ATTACHMENT_READ_BIT.0 != 0 {
856            if !first {
857                f.write_str(" | ")?;
858            }
859            f.write_str("_2_SHADER_TILE_ATTACHMENT_READ_BIT")?;
860            remaining &= !Self::_2_SHADER_TILE_ATTACHMENT_READ_BIT.0;
861            first = false;
862        }
863        if remaining & Self::_2_SHADER_TILE_ATTACHMENT_WRITE_BIT.0 != 0 {
864            if !first {
865                f.write_str(" | ")?;
866            }
867            f.write_str("_2_SHADER_TILE_ATTACHMENT_WRITE_BIT")?;
868            remaining &= !Self::_2_SHADER_TILE_ATTACHMENT_WRITE_BIT.0;
869            first = false;
870        }
871        if remaining & Self::_2_TRANSFORM_FEEDBACK_WRITE.0 != 0 {
872            if !first {
873                f.write_str(" | ")?;
874            }
875            f.write_str("_2_TRANSFORM_FEEDBACK_WRITE")?;
876            remaining &= !Self::_2_TRANSFORM_FEEDBACK_WRITE.0;
877            first = false;
878        }
879        if remaining & Self::_2_TRANSFORM_FEEDBACK_COUNTER_READ.0 != 0 {
880            if !first {
881                f.write_str(" | ")?;
882            }
883            f.write_str("_2_TRANSFORM_FEEDBACK_COUNTER_READ")?;
884            remaining &= !Self::_2_TRANSFORM_FEEDBACK_COUNTER_READ.0;
885            first = false;
886        }
887        if remaining & Self::_2_TRANSFORM_FEEDBACK_COUNTER_WRITE.0 != 0 {
888            if !first {
889                f.write_str(" | ")?;
890            }
891            f.write_str("_2_TRANSFORM_FEEDBACK_COUNTER_WRITE")?;
892            remaining &= !Self::_2_TRANSFORM_FEEDBACK_COUNTER_WRITE.0;
893            first = false;
894        }
895        if remaining & Self::_2_CONDITIONAL_RENDERING_READ.0 != 0 {
896            if !first {
897                f.write_str(" | ")?;
898            }
899            f.write_str("_2_CONDITIONAL_RENDERING_READ")?;
900            remaining &= !Self::_2_CONDITIONAL_RENDERING_READ.0;
901            first = false;
902        }
903        if remaining & Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0 != 0 {
904            if !first {
905                f.write_str(" | ")?;
906            }
907            f.write_str("_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ")?;
908            remaining &= !Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0;
909            first = false;
910        }
911        if remaining & Self::_2_ACCELERATION_STRUCTURE_READ.0 != 0 {
912            if !first {
913                f.write_str(" | ")?;
914            }
915            f.write_str("_2_ACCELERATION_STRUCTURE_READ")?;
916            remaining &= !Self::_2_ACCELERATION_STRUCTURE_READ.0;
917            first = false;
918        }
919        if remaining & Self::_2_ACCELERATION_STRUCTURE_WRITE.0 != 0 {
920            if !first {
921                f.write_str(" | ")?;
922            }
923            f.write_str("_2_ACCELERATION_STRUCTURE_WRITE")?;
924            remaining &= !Self::_2_ACCELERATION_STRUCTURE_WRITE.0;
925            first = false;
926        }
927        if remaining & Self::_2_FRAGMENT_DENSITY_MAP_READ.0 != 0 {
928            if !first {
929                f.write_str(" | ")?;
930            }
931            f.write_str("_2_FRAGMENT_DENSITY_MAP_READ")?;
932            remaining &= !Self::_2_FRAGMENT_DENSITY_MAP_READ.0;
933            first = false;
934        }
935        if remaining & Self::_2_COLOR_ATTACHMENT_READ_NONCOHERENT.0 != 0 {
936            if !first {
937                f.write_str(" | ")?;
938            }
939            f.write_str("_2_COLOR_ATTACHMENT_READ_NONCOHERENT")?;
940            remaining &= !Self::_2_COLOR_ATTACHMENT_READ_NONCOHERENT.0;
941            first = false;
942        }
943        if remaining & Self::_2_DESCRIPTOR_BUFFER_READ.0 != 0 {
944            if !first {
945                f.write_str(" | ")?;
946            }
947            f.write_str("_2_DESCRIPTOR_BUFFER_READ")?;
948            remaining &= !Self::_2_DESCRIPTOR_BUFFER_READ.0;
949            first = false;
950        }
951        if remaining & Self::_2_INVOCATION_MASK_READ_BIT.0 != 0 {
952            if !first {
953                f.write_str(" | ")?;
954            }
955            f.write_str("_2_INVOCATION_MASK_READ_BIT")?;
956            remaining &= !Self::_2_INVOCATION_MASK_READ_BIT.0;
957            first = false;
958        }
959        if remaining & Self::_2_SHADER_BINDING_TABLE_READ.0 != 0 {
960            if !first {
961                f.write_str(" | ")?;
962            }
963            f.write_str("_2_SHADER_BINDING_TABLE_READ")?;
964            remaining &= !Self::_2_SHADER_BINDING_TABLE_READ.0;
965            first = false;
966        }
967        if remaining & Self::_2_MICROMAP_READ.0 != 0 {
968            if !first {
969                f.write_str(" | ")?;
970            }
971            f.write_str("_2_MICROMAP_READ")?;
972            remaining &= !Self::_2_MICROMAP_READ.0;
973            first = false;
974        }
975        if remaining & Self::_2_MICROMAP_WRITE.0 != 0 {
976            if !first {
977                f.write_str(" | ")?;
978            }
979            f.write_str("_2_MICROMAP_WRITE")?;
980            remaining &= !Self::_2_MICROMAP_WRITE.0;
981            first = false;
982        }
983        if remaining & Self::_2_OPTICAL_FLOW_READ.0 != 0 {
984            if !first {
985                f.write_str(" | ")?;
986            }
987            f.write_str("_2_OPTICAL_FLOW_READ")?;
988            remaining &= !Self::_2_OPTICAL_FLOW_READ.0;
989            first = false;
990        }
991        if remaining & Self::_2_OPTICAL_FLOW_WRITE.0 != 0 {
992            if !first {
993                f.write_str(" | ")?;
994            }
995            f.write_str("_2_OPTICAL_FLOW_WRITE")?;
996            remaining &= !Self::_2_OPTICAL_FLOW_WRITE.0;
997            first = false;
998        }
999        if remaining & Self::_2_DATA_GRAPH_READ_BIT.0 != 0 {
1000            if !first {
1001                f.write_str(" | ")?;
1002            }
1003            f.write_str("_2_DATA_GRAPH_READ_BIT")?;
1004            remaining &= !Self::_2_DATA_GRAPH_READ_BIT.0;
1005            first = false;
1006        }
1007        if remaining & Self::_2_DATA_GRAPH_WRITE_BIT.0 != 0 {
1008            if !first {
1009                f.write_str(" | ")?;
1010            }
1011            f.write_str("_2_DATA_GRAPH_WRITE_BIT")?;
1012            remaining &= !Self::_2_DATA_GRAPH_WRITE_BIT.0;
1013            first = false;
1014        }
1015        if remaining & Self::_2_MEMORY_DECOMPRESSION_READ.0 != 0 {
1016            if !first {
1017                f.write_str(" | ")?;
1018            }
1019            f.write_str("_2_MEMORY_DECOMPRESSION_READ")?;
1020            remaining &= !Self::_2_MEMORY_DECOMPRESSION_READ.0;
1021            first = false;
1022        }
1023        if remaining & Self::_2_MEMORY_DECOMPRESSION_WRITE.0 != 0 {
1024            if !first {
1025                f.write_str(" | ")?;
1026            }
1027            f.write_str("_2_MEMORY_DECOMPRESSION_WRITE")?;
1028            remaining &= !Self::_2_MEMORY_DECOMPRESSION_WRITE.0;
1029            first = false;
1030        }
1031        if remaining != 0u64 {
1032            if !first {
1033                f.write_str(" | ")?;
1034            }
1035            write!(f, "{:#x}", remaining)?;
1036        } else if first {
1037            f.write_str("(empty)")?;
1038        }
1039        Ok(())
1040    }
1041}
1042///[`VkAccessFlagBits3KHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits3KHR.html)
1043#[repr(transparent)]
1044#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
1045#[doc(alias = "VkAccessFlagBits3KHR")]
1046pub struct AccessFlagBits3KHR(u64);
1047impl AccessFlagBits3KHR {
1048    #[inline]
1049    pub const fn empty() -> Self {
1050        Self(0u64)
1051    }
1052    #[inline]
1053    pub const fn from_raw(value: u64) -> Self {
1054        Self(value)
1055    }
1056    #[inline]
1057    pub const fn as_raw(self) -> u64 {
1058        self.0
1059    }
1060    #[inline]
1061    pub const fn is_empty(self) -> bool {
1062        self.0 == 0u64
1063    }
1064    #[inline]
1065    pub const fn contains(self, other: Self) -> bool {
1066        (self.0 & other.0) == other.0
1067    }
1068    pub const ACCESS_3_NONE: Self = Self(0u64);
1069}
1070impl core::ops::BitOr for AccessFlagBits3KHR {
1071    type Output = Self;
1072    #[inline]
1073    fn bitor(self, rhs: Self) -> Self {
1074        Self(self.0 | rhs.0)
1075    }
1076}
1077impl core::ops::BitOrAssign for AccessFlagBits3KHR {
1078    #[inline]
1079    fn bitor_assign(&mut self, rhs: Self) {
1080        self.0 |= rhs.0;
1081    }
1082}
1083impl core::ops::BitAnd for AccessFlagBits3KHR {
1084    type Output = Self;
1085    #[inline]
1086    fn bitand(self, rhs: Self) -> Self {
1087        Self(self.0 & rhs.0)
1088    }
1089}
1090impl core::ops::BitAndAssign for AccessFlagBits3KHR {
1091    #[inline]
1092    fn bitand_assign(&mut self, rhs: Self) {
1093        self.0 &= rhs.0;
1094    }
1095}
1096impl core::ops::BitXor for AccessFlagBits3KHR {
1097    type Output = Self;
1098    #[inline]
1099    fn bitxor(self, rhs: Self) -> Self {
1100        Self(self.0 ^ rhs.0)
1101    }
1102}
1103impl core::ops::BitXorAssign for AccessFlagBits3KHR {
1104    #[inline]
1105    fn bitxor_assign(&mut self, rhs: Self) {
1106        self.0 ^= rhs.0;
1107    }
1108}
1109impl core::ops::Not for AccessFlagBits3KHR {
1110    type Output = Self;
1111    #[inline]
1112    fn not(self) -> Self {
1113        Self(!self.0)
1114    }
1115}
1116impl core::fmt::Debug for AccessFlagBits3KHR {
1117    #[allow(unused_mut, unused_variables)]
1118    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1119        let mut first = true;
1120        let mut remaining = self.0;
1121        if remaining != 0u64 {
1122            if !first {
1123                f.write_str(" | ")?;
1124            }
1125            write!(f, "{:#x}", remaining)?;
1126        } else if first {
1127            f.write_str("(empty)")?;
1128        }
1129        Ok(())
1130    }
1131}
1132///[`VkAcquireProfilingLockFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireProfilingLockFlagBitsKHR.html)
1133#[repr(transparent)]
1134#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
1135#[doc(alias = "VkAcquireProfilingLockFlagBitsKHR")]
1136pub struct AcquireProfilingLockFlagBitsKHR(u32);
1137impl AcquireProfilingLockFlagBitsKHR {
1138    #[inline]
1139    pub const fn empty() -> Self {
1140        Self(0u32)
1141    }
1142    #[inline]
1143    pub const fn from_raw(value: u32) -> Self {
1144        Self(value)
1145    }
1146    #[inline]
1147    pub const fn as_raw(self) -> u32 {
1148        self.0
1149    }
1150    #[inline]
1151    pub const fn is_empty(self) -> bool {
1152        self.0 == 0u32
1153    }
1154    #[inline]
1155    pub const fn contains(self, other: Self) -> bool {
1156        (self.0 & other.0) == other.0
1157    }
1158}
1159impl core::ops::BitOr for AcquireProfilingLockFlagBitsKHR {
1160    type Output = Self;
1161    #[inline]
1162    fn bitor(self, rhs: Self) -> Self {
1163        Self(self.0 | rhs.0)
1164    }
1165}
1166impl core::ops::BitOrAssign for AcquireProfilingLockFlagBitsKHR {
1167    #[inline]
1168    fn bitor_assign(&mut self, rhs: Self) {
1169        self.0 |= rhs.0;
1170    }
1171}
1172impl core::ops::BitAnd for AcquireProfilingLockFlagBitsKHR {
1173    type Output = Self;
1174    #[inline]
1175    fn bitand(self, rhs: Self) -> Self {
1176        Self(self.0 & rhs.0)
1177    }
1178}
1179impl core::ops::BitAndAssign for AcquireProfilingLockFlagBitsKHR {
1180    #[inline]
1181    fn bitand_assign(&mut self, rhs: Self) {
1182        self.0 &= rhs.0;
1183    }
1184}
1185impl core::ops::BitXor for AcquireProfilingLockFlagBitsKHR {
1186    type Output = Self;
1187    #[inline]
1188    fn bitxor(self, rhs: Self) -> Self {
1189        Self(self.0 ^ rhs.0)
1190    }
1191}
1192impl core::ops::BitXorAssign for AcquireProfilingLockFlagBitsKHR {
1193    #[inline]
1194    fn bitxor_assign(&mut self, rhs: Self) {
1195        self.0 ^= rhs.0;
1196    }
1197}
1198impl core::ops::Not for AcquireProfilingLockFlagBitsKHR {
1199    type Output = Self;
1200    #[inline]
1201    fn not(self) -> Self {
1202        Self(!self.0)
1203    }
1204}
1205impl core::fmt::Debug for AcquireProfilingLockFlagBitsKHR {
1206    #[allow(unused_mut, unused_variables)]
1207    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1208        let mut first = true;
1209        let mut remaining = self.0;
1210        if remaining != 0u32 {
1211            if !first {
1212                f.write_str(" | ")?;
1213            }
1214            write!(f, "{:#x}", remaining)?;
1215        } else if first {
1216            f.write_str("(empty)")?;
1217        }
1218        Ok(())
1219    }
1220}
1221///[`VkAddressCommandFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCommandFlagBitsKHR.html)
1222#[repr(transparent)]
1223#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
1224#[doc(alias = "VkAddressCommandFlagBitsKHR")]
1225pub struct AddressCommandFlagBitsKHR(u32);
1226impl AddressCommandFlagBitsKHR {
1227    #[inline]
1228    pub const fn empty() -> Self {
1229        Self(0u32)
1230    }
1231    #[inline]
1232    pub const fn from_raw(value: u32) -> Self {
1233        Self(value)
1234    }
1235    #[inline]
1236    pub const fn as_raw(self) -> u32 {
1237        self.0
1238    }
1239    #[inline]
1240    pub const fn is_empty(self) -> bool {
1241        self.0 == 0u32
1242    }
1243    #[inline]
1244    pub const fn contains(self, other: Self) -> bool {
1245        (self.0 & other.0) == other.0
1246    }
1247    ///Bit 0.
1248    pub const PROTECTED: Self = Self(1u32);
1249    ///Bit 1.
1250    pub const FULLY_BOUND: Self = Self(2u32);
1251    ///Bit 2.
1252    pub const STORAGE_BUFFER_USAGE: Self = Self(4u32);
1253    ///Bit 3.
1254    pub const UNKNOWN_STORAGE_BUFFER_USAGE: Self = Self(8u32);
1255    ///Bit 4.
1256    pub const TRANSFORM_FEEDBACK_BUFFER_USAGE: Self = Self(16u32);
1257    ///Bit 5.
1258    pub const UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE: Self = Self(32u32);
1259}
1260impl core::ops::BitOr for AddressCommandFlagBitsKHR {
1261    type Output = Self;
1262    #[inline]
1263    fn bitor(self, rhs: Self) -> Self {
1264        Self(self.0 | rhs.0)
1265    }
1266}
1267impl core::ops::BitOrAssign for AddressCommandFlagBitsKHR {
1268    #[inline]
1269    fn bitor_assign(&mut self, rhs: Self) {
1270        self.0 |= rhs.0;
1271    }
1272}
1273impl core::ops::BitAnd for AddressCommandFlagBitsKHR {
1274    type Output = Self;
1275    #[inline]
1276    fn bitand(self, rhs: Self) -> Self {
1277        Self(self.0 & rhs.0)
1278    }
1279}
1280impl core::ops::BitAndAssign for AddressCommandFlagBitsKHR {
1281    #[inline]
1282    fn bitand_assign(&mut self, rhs: Self) {
1283        self.0 &= rhs.0;
1284    }
1285}
1286impl core::ops::BitXor for AddressCommandFlagBitsKHR {
1287    type Output = Self;
1288    #[inline]
1289    fn bitxor(self, rhs: Self) -> Self {
1290        Self(self.0 ^ rhs.0)
1291    }
1292}
1293impl core::ops::BitXorAssign for AddressCommandFlagBitsKHR {
1294    #[inline]
1295    fn bitxor_assign(&mut self, rhs: Self) {
1296        self.0 ^= rhs.0;
1297    }
1298}
1299impl core::ops::Not for AddressCommandFlagBitsKHR {
1300    type Output = Self;
1301    #[inline]
1302    fn not(self) -> Self {
1303        Self(!self.0)
1304    }
1305}
1306impl core::fmt::Debug for AddressCommandFlagBitsKHR {
1307    #[allow(unused_mut, unused_variables)]
1308    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1309        let mut first = true;
1310        let mut remaining = self.0;
1311        if remaining & Self::PROTECTED.0 != 0 {
1312            if !first {
1313                f.write_str(" | ")?;
1314            }
1315            f.write_str("PROTECTED")?;
1316            remaining &= !Self::PROTECTED.0;
1317            first = false;
1318        }
1319        if remaining & Self::FULLY_BOUND.0 != 0 {
1320            if !first {
1321                f.write_str(" | ")?;
1322            }
1323            f.write_str("FULLY_BOUND")?;
1324            remaining &= !Self::FULLY_BOUND.0;
1325            first = false;
1326        }
1327        if remaining & Self::STORAGE_BUFFER_USAGE.0 != 0 {
1328            if !first {
1329                f.write_str(" | ")?;
1330            }
1331            f.write_str("STORAGE_BUFFER_USAGE")?;
1332            remaining &= !Self::STORAGE_BUFFER_USAGE.0;
1333            first = false;
1334        }
1335        if remaining & Self::UNKNOWN_STORAGE_BUFFER_USAGE.0 != 0 {
1336            if !first {
1337                f.write_str(" | ")?;
1338            }
1339            f.write_str("UNKNOWN_STORAGE_BUFFER_USAGE")?;
1340            remaining &= !Self::UNKNOWN_STORAGE_BUFFER_USAGE.0;
1341            first = false;
1342        }
1343        if remaining & Self::TRANSFORM_FEEDBACK_BUFFER_USAGE.0 != 0 {
1344            if !first {
1345                f.write_str(" | ")?;
1346            }
1347            f.write_str("TRANSFORM_FEEDBACK_BUFFER_USAGE")?;
1348            remaining &= !Self::TRANSFORM_FEEDBACK_BUFFER_USAGE.0;
1349            first = false;
1350        }
1351        if remaining & Self::UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE.0 != 0 {
1352            if !first {
1353                f.write_str(" | ")?;
1354            }
1355            f.write_str("UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE")?;
1356            remaining &= !Self::UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE.0;
1357            first = false;
1358        }
1359        if remaining != 0u32 {
1360            if !first {
1361                f.write_str(" | ")?;
1362            }
1363            write!(f, "{:#x}", remaining)?;
1364        } else if first {
1365            f.write_str("(empty)")?;
1366        }
1367        Ok(())
1368    }
1369}
1370///[`VkAddressCopyFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCopyFlagBitsKHR.html)
1371#[repr(transparent)]
1372#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
1373#[doc(alias = "VkAddressCopyFlagBitsKHR")]
1374pub struct AddressCopyFlagBitsKHR(u32);
1375impl AddressCopyFlagBitsKHR {
1376    #[inline]
1377    pub const fn empty() -> Self {
1378        Self(0u32)
1379    }
1380    #[inline]
1381    pub const fn from_raw(value: u32) -> Self {
1382        Self(value)
1383    }
1384    #[inline]
1385    pub const fn as_raw(self) -> u32 {
1386        self.0
1387    }
1388    #[inline]
1389    pub const fn is_empty(self) -> bool {
1390        self.0 == 0u32
1391    }
1392    #[inline]
1393    pub const fn contains(self, other: Self) -> bool {
1394        (self.0 & other.0) == other.0
1395    }
1396    ///Bit 0.
1397    pub const DEVICE_LOCAL: Self = Self(1u32);
1398    ///Bit 1.
1399    pub const SPARSE: Self = Self(2u32);
1400    ///Bit 2.
1401    pub const PROTECTED: Self = Self(4u32);
1402}
1403impl core::ops::BitOr for AddressCopyFlagBitsKHR {
1404    type Output = Self;
1405    #[inline]
1406    fn bitor(self, rhs: Self) -> Self {
1407        Self(self.0 | rhs.0)
1408    }
1409}
1410impl core::ops::BitOrAssign for AddressCopyFlagBitsKHR {
1411    #[inline]
1412    fn bitor_assign(&mut self, rhs: Self) {
1413        self.0 |= rhs.0;
1414    }
1415}
1416impl core::ops::BitAnd for AddressCopyFlagBitsKHR {
1417    type Output = Self;
1418    #[inline]
1419    fn bitand(self, rhs: Self) -> Self {
1420        Self(self.0 & rhs.0)
1421    }
1422}
1423impl core::ops::BitAndAssign for AddressCopyFlagBitsKHR {
1424    #[inline]
1425    fn bitand_assign(&mut self, rhs: Self) {
1426        self.0 &= rhs.0;
1427    }
1428}
1429impl core::ops::BitXor for AddressCopyFlagBitsKHR {
1430    type Output = Self;
1431    #[inline]
1432    fn bitxor(self, rhs: Self) -> Self {
1433        Self(self.0 ^ rhs.0)
1434    }
1435}
1436impl core::ops::BitXorAssign for AddressCopyFlagBitsKHR {
1437    #[inline]
1438    fn bitxor_assign(&mut self, rhs: Self) {
1439        self.0 ^= rhs.0;
1440    }
1441}
1442impl core::ops::Not for AddressCopyFlagBitsKHR {
1443    type Output = Self;
1444    #[inline]
1445    fn not(self) -> Self {
1446        Self(!self.0)
1447    }
1448}
1449impl core::fmt::Debug for AddressCopyFlagBitsKHR {
1450    #[allow(unused_mut, unused_variables)]
1451    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1452        let mut first = true;
1453        let mut remaining = self.0;
1454        if remaining & Self::DEVICE_LOCAL.0 != 0 {
1455            if !first {
1456                f.write_str(" | ")?;
1457            }
1458            f.write_str("DEVICE_LOCAL")?;
1459            remaining &= !Self::DEVICE_LOCAL.0;
1460            first = false;
1461        }
1462        if remaining & Self::SPARSE.0 != 0 {
1463            if !first {
1464                f.write_str(" | ")?;
1465            }
1466            f.write_str("SPARSE")?;
1467            remaining &= !Self::SPARSE.0;
1468            first = false;
1469        }
1470        if remaining & Self::PROTECTED.0 != 0 {
1471            if !first {
1472                f.write_str(" | ")?;
1473            }
1474            f.write_str("PROTECTED")?;
1475            remaining &= !Self::PROTECTED.0;
1476            first = false;
1477        }
1478        if remaining != 0u32 {
1479            if !first {
1480                f.write_str(" | ")?;
1481            }
1482            write!(f, "{:#x}", remaining)?;
1483        } else if first {
1484            f.write_str("(empty)")?;
1485        }
1486        Ok(())
1487    }
1488}
1489///[`VkAttachmentDescriptionFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionFlagBits.html)
1490#[repr(transparent)]
1491#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
1492#[doc(alias = "VkAttachmentDescriptionFlagBits")]
1493pub struct AttachmentDescriptionFlagBits(u32);
1494impl AttachmentDescriptionFlagBits {
1495    #[inline]
1496    pub const fn empty() -> Self {
1497        Self(0u32)
1498    }
1499    #[inline]
1500    pub const fn from_raw(value: u32) -> Self {
1501        Self(value)
1502    }
1503    #[inline]
1504    pub const fn as_raw(self) -> u32 {
1505        self.0
1506    }
1507    #[inline]
1508    pub const fn is_empty(self) -> bool {
1509        self.0 == 0u32
1510    }
1511    #[inline]
1512    pub const fn contains(self, other: Self) -> bool {
1513        (self.0 & other.0) == other.0
1514    }
1515    ///Bit 0.
1516    pub const MAY_ALIAS: Self = Self(1u32);
1517    ///Bit 1.
1518    pub const RESOLVE_SKIP_TRANSFER_FUNCTION: Self = Self(2u32);
1519    ///Bit 2.
1520    pub const RESOLVE_ENABLE_TRANSFER_FUNCTION: Self = Self(4u32);
1521}
1522impl core::ops::BitOr for AttachmentDescriptionFlagBits {
1523    type Output = Self;
1524    #[inline]
1525    fn bitor(self, rhs: Self) -> Self {
1526        Self(self.0 | rhs.0)
1527    }
1528}
1529impl core::ops::BitOrAssign for AttachmentDescriptionFlagBits {
1530    #[inline]
1531    fn bitor_assign(&mut self, rhs: Self) {
1532        self.0 |= rhs.0;
1533    }
1534}
1535impl core::ops::BitAnd for AttachmentDescriptionFlagBits {
1536    type Output = Self;
1537    #[inline]
1538    fn bitand(self, rhs: Self) -> Self {
1539        Self(self.0 & rhs.0)
1540    }
1541}
1542impl core::ops::BitAndAssign for AttachmentDescriptionFlagBits {
1543    #[inline]
1544    fn bitand_assign(&mut self, rhs: Self) {
1545        self.0 &= rhs.0;
1546    }
1547}
1548impl core::ops::BitXor for AttachmentDescriptionFlagBits {
1549    type Output = Self;
1550    #[inline]
1551    fn bitxor(self, rhs: Self) -> Self {
1552        Self(self.0 ^ rhs.0)
1553    }
1554}
1555impl core::ops::BitXorAssign for AttachmentDescriptionFlagBits {
1556    #[inline]
1557    fn bitxor_assign(&mut self, rhs: Self) {
1558        self.0 ^= rhs.0;
1559    }
1560}
1561impl core::ops::Not for AttachmentDescriptionFlagBits {
1562    type Output = Self;
1563    #[inline]
1564    fn not(self) -> Self {
1565        Self(!self.0)
1566    }
1567}
1568impl core::fmt::Debug for AttachmentDescriptionFlagBits {
1569    #[allow(unused_mut, unused_variables)]
1570    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1571        let mut first = true;
1572        let mut remaining = self.0;
1573        if remaining & Self::MAY_ALIAS.0 != 0 {
1574            if !first {
1575                f.write_str(" | ")?;
1576            }
1577            f.write_str("MAY_ALIAS")?;
1578            remaining &= !Self::MAY_ALIAS.0;
1579            first = false;
1580        }
1581        if remaining & Self::RESOLVE_SKIP_TRANSFER_FUNCTION.0 != 0 {
1582            if !first {
1583                f.write_str(" | ")?;
1584            }
1585            f.write_str("RESOLVE_SKIP_TRANSFER_FUNCTION")?;
1586            remaining &= !Self::RESOLVE_SKIP_TRANSFER_FUNCTION.0;
1587            first = false;
1588        }
1589        if remaining & Self::RESOLVE_ENABLE_TRANSFER_FUNCTION.0 != 0 {
1590            if !first {
1591                f.write_str(" | ")?;
1592            }
1593            f.write_str("RESOLVE_ENABLE_TRANSFER_FUNCTION")?;
1594            remaining &= !Self::RESOLVE_ENABLE_TRANSFER_FUNCTION.0;
1595            first = false;
1596        }
1597        if remaining != 0u32 {
1598            if !first {
1599                f.write_str(" | ")?;
1600            }
1601            write!(f, "{:#x}", remaining)?;
1602        } else if first {
1603            f.write_str("(empty)")?;
1604        }
1605        Ok(())
1606    }
1607}
1608///[`VkBufferCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateFlagBits.html)
1609#[repr(transparent)]
1610#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
1611#[doc(alias = "VkBufferCreateFlagBits")]
1612pub struct BufferCreateFlagBits(u32);
1613impl BufferCreateFlagBits {
1614    #[inline]
1615    pub const fn empty() -> Self {
1616        Self(0u32)
1617    }
1618    #[inline]
1619    pub const fn from_raw(value: u32) -> Self {
1620        Self(value)
1621    }
1622    #[inline]
1623    pub const fn as_raw(self) -> u32 {
1624        self.0
1625    }
1626    #[inline]
1627    pub const fn is_empty(self) -> bool {
1628        self.0 == 0u32
1629    }
1630    #[inline]
1631    pub const fn contains(self, other: Self) -> bool {
1632        (self.0 & other.0) == other.0
1633    }
1634    ///Bit 0.
1635    pub const SPARSE_BINDING: Self = Self(1u32);
1636    ///Bit 1.
1637    pub const SPARSE_RESIDENCY: Self = Self(2u32);
1638    ///Bit 2.
1639    pub const SPARSE_ALIASED: Self = Self(4u32);
1640    ///Bit 3.
1641    pub const PROTECTED: Self = Self(8u32);
1642    ///Bit 4.
1643    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(16u32);
1644    ///Bit 5.
1645    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self(32u32);
1646    ///Bit 6.
1647    pub const VIDEO_PROFILE_INDEPENDENT: Self = Self(64u32);
1648}
1649impl core::ops::BitOr for BufferCreateFlagBits {
1650    type Output = Self;
1651    #[inline]
1652    fn bitor(self, rhs: Self) -> Self {
1653        Self(self.0 | rhs.0)
1654    }
1655}
1656impl core::ops::BitOrAssign for BufferCreateFlagBits {
1657    #[inline]
1658    fn bitor_assign(&mut self, rhs: Self) {
1659        self.0 |= rhs.0;
1660    }
1661}
1662impl core::ops::BitAnd for BufferCreateFlagBits {
1663    type Output = Self;
1664    #[inline]
1665    fn bitand(self, rhs: Self) -> Self {
1666        Self(self.0 & rhs.0)
1667    }
1668}
1669impl core::ops::BitAndAssign for BufferCreateFlagBits {
1670    #[inline]
1671    fn bitand_assign(&mut self, rhs: Self) {
1672        self.0 &= rhs.0;
1673    }
1674}
1675impl core::ops::BitXor for BufferCreateFlagBits {
1676    type Output = Self;
1677    #[inline]
1678    fn bitxor(self, rhs: Self) -> Self {
1679        Self(self.0 ^ rhs.0)
1680    }
1681}
1682impl core::ops::BitXorAssign for BufferCreateFlagBits {
1683    #[inline]
1684    fn bitxor_assign(&mut self, rhs: Self) {
1685        self.0 ^= rhs.0;
1686    }
1687}
1688impl core::ops::Not for BufferCreateFlagBits {
1689    type Output = Self;
1690    #[inline]
1691    fn not(self) -> Self {
1692        Self(!self.0)
1693    }
1694}
1695impl core::fmt::Debug for BufferCreateFlagBits {
1696    #[allow(unused_mut, unused_variables)]
1697    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1698        let mut first = true;
1699        let mut remaining = self.0;
1700        if remaining & Self::SPARSE_BINDING.0 != 0 {
1701            if !first {
1702                f.write_str(" | ")?;
1703            }
1704            f.write_str("SPARSE_BINDING")?;
1705            remaining &= !Self::SPARSE_BINDING.0;
1706            first = false;
1707        }
1708        if remaining & Self::SPARSE_RESIDENCY.0 != 0 {
1709            if !first {
1710                f.write_str(" | ")?;
1711            }
1712            f.write_str("SPARSE_RESIDENCY")?;
1713            remaining &= !Self::SPARSE_RESIDENCY.0;
1714            first = false;
1715        }
1716        if remaining & Self::SPARSE_ALIASED.0 != 0 {
1717            if !first {
1718                f.write_str(" | ")?;
1719            }
1720            f.write_str("SPARSE_ALIASED")?;
1721            remaining &= !Self::SPARSE_ALIASED.0;
1722            first = false;
1723        }
1724        if remaining & Self::PROTECTED.0 != 0 {
1725            if !first {
1726                f.write_str(" | ")?;
1727            }
1728            f.write_str("PROTECTED")?;
1729            remaining &= !Self::PROTECTED.0;
1730            first = false;
1731        }
1732        if remaining & Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0 != 0 {
1733            if !first {
1734                f.write_str(" | ")?;
1735            }
1736            f.write_str("DEVICE_ADDRESS_CAPTURE_REPLAY")?;
1737            remaining &= !Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0;
1738            first = false;
1739        }
1740        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0 != 0 {
1741            if !first {
1742                f.write_str(" | ")?;
1743            }
1744            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY")?;
1745            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0;
1746            first = false;
1747        }
1748        if remaining & Self::VIDEO_PROFILE_INDEPENDENT.0 != 0 {
1749            if !first {
1750                f.write_str(" | ")?;
1751            }
1752            f.write_str("VIDEO_PROFILE_INDEPENDENT")?;
1753            remaining &= !Self::VIDEO_PROFILE_INDEPENDENT.0;
1754            first = false;
1755        }
1756        if remaining != 0u32 {
1757            if !first {
1758                f.write_str(" | ")?;
1759            }
1760            write!(f, "{:#x}", remaining)?;
1761        } else if first {
1762            f.write_str("(empty)")?;
1763        }
1764        Ok(())
1765    }
1766}
1767///[`VkBufferUsageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits.html)
1768#[repr(transparent)]
1769#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
1770#[doc(alias = "VkBufferUsageFlagBits")]
1771pub struct BufferUsageFlagBits(u32);
1772impl BufferUsageFlagBits {
1773    #[inline]
1774    pub const fn empty() -> Self {
1775        Self(0u32)
1776    }
1777    #[inline]
1778    pub const fn from_raw(value: u32) -> Self {
1779        Self(value)
1780    }
1781    #[inline]
1782    pub const fn as_raw(self) -> u32 {
1783        self.0
1784    }
1785    #[inline]
1786    pub const fn is_empty(self) -> bool {
1787        self.0 == 0u32
1788    }
1789    #[inline]
1790    pub const fn contains(self, other: Self) -> bool {
1791        (self.0 & other.0) == other.0
1792    }
1793    ///Bit 0.
1794    pub const TRANSFER_SRC: Self = Self(1u32);
1795    ///Bit 1.
1796    pub const TRANSFER_DST: Self = Self(2u32);
1797    ///Bit 2.
1798    pub const UNIFORM_TEXEL_BUFFER: Self = Self(4u32);
1799    ///Bit 3.
1800    pub const STORAGE_TEXEL_BUFFER: Self = Self(8u32);
1801    ///Bit 4.
1802    pub const UNIFORM_BUFFER: Self = Self(16u32);
1803    ///Bit 5.
1804    pub const STORAGE_BUFFER: Self = Self(32u32);
1805    ///Bit 6.
1806    pub const INDEX_BUFFER: Self = Self(64u32);
1807    ///Bit 7.
1808    pub const VERTEX_BUFFER: Self = Self(128u32);
1809    ///Bit 8.
1810    pub const INDIRECT_BUFFER: Self = Self(256u32);
1811    ///Bit 17.
1812    pub const SHADER_DEVICE_ADDRESS: Self = Self(131072u32);
1813    ///Bit 13.
1814    pub const VIDEO_DECODE_SRC: Self = Self(8192u32);
1815    ///Bit 14.
1816    pub const VIDEO_DECODE_DST: Self = Self(16384u32);
1817    ///Bit 11.
1818    pub const TRANSFORM_FEEDBACK_BUFFER: Self = Self(2048u32);
1819    ///Bit 12.
1820    pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER: Self = Self(4096u32);
1821    ///Bit 9.
1822    pub const CONDITIONAL_RENDERING: Self = Self(512u32);
1823    ///Bit 25.
1824    pub const EXECUTION_GRAPH_SCRATCH_BIT: Self = Self(33554432u32);
1825    ///Bit 28.
1826    pub const DESCRIPTOR_HEAP: Self = Self(268435456u32);
1827    ///Bit 19.
1828    pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY: Self = Self(524288u32);
1829    ///Bit 20.
1830    pub const ACCELERATION_STRUCTURE_STORAGE: Self = Self(1048576u32);
1831    ///Bit 10.
1832    pub const SHADER_BINDING_TABLE: Self = Self(1024u32);
1833    pub const RAY_TRACING: Self = Self::SHADER_BINDING_TABLE;
1834    ///Bit 15.
1835    pub const VIDEO_ENCODE_DST: Self = Self(32768u32);
1836    ///Bit 16.
1837    pub const VIDEO_ENCODE_SRC: Self = Self(65536u32);
1838    ///Bit 21.
1839    pub const SAMPLER_DESCRIPTOR_BUFFER: Self = Self(2097152u32);
1840    ///Bit 22.
1841    pub const RESOURCE_DESCRIPTOR_BUFFER: Self = Self(4194304u32);
1842    ///Bit 26.
1843    pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER: Self = Self(67108864u32);
1844    ///Bit 23.
1845    pub const MICROMAP_BUILD_INPUT_READ_ONLY: Self = Self(8388608u32);
1846    ///Bit 24.
1847    pub const MICROMAP_STORAGE: Self = Self(16777216u32);
1848    ///Bit 27.
1849    pub const TILE_MEMORY_BIT: Self = Self(134217728u32);
1850}
1851impl core::ops::BitOr for BufferUsageFlagBits {
1852    type Output = Self;
1853    #[inline]
1854    fn bitor(self, rhs: Self) -> Self {
1855        Self(self.0 | rhs.0)
1856    }
1857}
1858impl core::ops::BitOrAssign for BufferUsageFlagBits {
1859    #[inline]
1860    fn bitor_assign(&mut self, rhs: Self) {
1861        self.0 |= rhs.0;
1862    }
1863}
1864impl core::ops::BitAnd for BufferUsageFlagBits {
1865    type Output = Self;
1866    #[inline]
1867    fn bitand(self, rhs: Self) -> Self {
1868        Self(self.0 & rhs.0)
1869    }
1870}
1871impl core::ops::BitAndAssign for BufferUsageFlagBits {
1872    #[inline]
1873    fn bitand_assign(&mut self, rhs: Self) {
1874        self.0 &= rhs.0;
1875    }
1876}
1877impl core::ops::BitXor for BufferUsageFlagBits {
1878    type Output = Self;
1879    #[inline]
1880    fn bitxor(self, rhs: Self) -> Self {
1881        Self(self.0 ^ rhs.0)
1882    }
1883}
1884impl core::ops::BitXorAssign for BufferUsageFlagBits {
1885    #[inline]
1886    fn bitxor_assign(&mut self, rhs: Self) {
1887        self.0 ^= rhs.0;
1888    }
1889}
1890impl core::ops::Not for BufferUsageFlagBits {
1891    type Output = Self;
1892    #[inline]
1893    fn not(self) -> Self {
1894        Self(!self.0)
1895    }
1896}
1897impl core::fmt::Debug for BufferUsageFlagBits {
1898    #[allow(unused_mut, unused_variables)]
1899    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1900        let mut first = true;
1901        let mut remaining = self.0;
1902        if remaining & Self::TRANSFER_SRC.0 != 0 {
1903            if !first {
1904                f.write_str(" | ")?;
1905            }
1906            f.write_str("TRANSFER_SRC")?;
1907            remaining &= !Self::TRANSFER_SRC.0;
1908            first = false;
1909        }
1910        if remaining & Self::TRANSFER_DST.0 != 0 {
1911            if !first {
1912                f.write_str(" | ")?;
1913            }
1914            f.write_str("TRANSFER_DST")?;
1915            remaining &= !Self::TRANSFER_DST.0;
1916            first = false;
1917        }
1918        if remaining & Self::UNIFORM_TEXEL_BUFFER.0 != 0 {
1919            if !first {
1920                f.write_str(" | ")?;
1921            }
1922            f.write_str("UNIFORM_TEXEL_BUFFER")?;
1923            remaining &= !Self::UNIFORM_TEXEL_BUFFER.0;
1924            first = false;
1925        }
1926        if remaining & Self::STORAGE_TEXEL_BUFFER.0 != 0 {
1927            if !first {
1928                f.write_str(" | ")?;
1929            }
1930            f.write_str("STORAGE_TEXEL_BUFFER")?;
1931            remaining &= !Self::STORAGE_TEXEL_BUFFER.0;
1932            first = false;
1933        }
1934        if remaining & Self::UNIFORM_BUFFER.0 != 0 {
1935            if !first {
1936                f.write_str(" | ")?;
1937            }
1938            f.write_str("UNIFORM_BUFFER")?;
1939            remaining &= !Self::UNIFORM_BUFFER.0;
1940            first = false;
1941        }
1942        if remaining & Self::STORAGE_BUFFER.0 != 0 {
1943            if !first {
1944                f.write_str(" | ")?;
1945            }
1946            f.write_str("STORAGE_BUFFER")?;
1947            remaining &= !Self::STORAGE_BUFFER.0;
1948            first = false;
1949        }
1950        if remaining & Self::INDEX_BUFFER.0 != 0 {
1951            if !first {
1952                f.write_str(" | ")?;
1953            }
1954            f.write_str("INDEX_BUFFER")?;
1955            remaining &= !Self::INDEX_BUFFER.0;
1956            first = false;
1957        }
1958        if remaining & Self::VERTEX_BUFFER.0 != 0 {
1959            if !first {
1960                f.write_str(" | ")?;
1961            }
1962            f.write_str("VERTEX_BUFFER")?;
1963            remaining &= !Self::VERTEX_BUFFER.0;
1964            first = false;
1965        }
1966        if remaining & Self::INDIRECT_BUFFER.0 != 0 {
1967            if !first {
1968                f.write_str(" | ")?;
1969            }
1970            f.write_str("INDIRECT_BUFFER")?;
1971            remaining &= !Self::INDIRECT_BUFFER.0;
1972            first = false;
1973        }
1974        if remaining & Self::SHADER_DEVICE_ADDRESS.0 != 0 {
1975            if !first {
1976                f.write_str(" | ")?;
1977            }
1978            f.write_str("SHADER_DEVICE_ADDRESS")?;
1979            remaining &= !Self::SHADER_DEVICE_ADDRESS.0;
1980            first = false;
1981        }
1982        if remaining & Self::VIDEO_DECODE_SRC.0 != 0 {
1983            if !first {
1984                f.write_str(" | ")?;
1985            }
1986            f.write_str("VIDEO_DECODE_SRC")?;
1987            remaining &= !Self::VIDEO_DECODE_SRC.0;
1988            first = false;
1989        }
1990        if remaining & Self::VIDEO_DECODE_DST.0 != 0 {
1991            if !first {
1992                f.write_str(" | ")?;
1993            }
1994            f.write_str("VIDEO_DECODE_DST")?;
1995            remaining &= !Self::VIDEO_DECODE_DST.0;
1996            first = false;
1997        }
1998        if remaining & Self::TRANSFORM_FEEDBACK_BUFFER.0 != 0 {
1999            if !first {
2000                f.write_str(" | ")?;
2001            }
2002            f.write_str("TRANSFORM_FEEDBACK_BUFFER")?;
2003            remaining &= !Self::TRANSFORM_FEEDBACK_BUFFER.0;
2004            first = false;
2005        }
2006        if remaining & Self::TRANSFORM_FEEDBACK_COUNTER_BUFFER.0 != 0 {
2007            if !first {
2008                f.write_str(" | ")?;
2009            }
2010            f.write_str("TRANSFORM_FEEDBACK_COUNTER_BUFFER")?;
2011            remaining &= !Self::TRANSFORM_FEEDBACK_COUNTER_BUFFER.0;
2012            first = false;
2013        }
2014        if remaining & Self::CONDITIONAL_RENDERING.0 != 0 {
2015            if !first {
2016                f.write_str(" | ")?;
2017            }
2018            f.write_str("CONDITIONAL_RENDERING")?;
2019            remaining &= !Self::CONDITIONAL_RENDERING.0;
2020            first = false;
2021        }
2022        if remaining & Self::EXECUTION_GRAPH_SCRATCH_BIT.0 != 0 {
2023            if !first {
2024                f.write_str(" | ")?;
2025            }
2026            f.write_str("EXECUTION_GRAPH_SCRATCH_BIT")?;
2027            remaining &= !Self::EXECUTION_GRAPH_SCRATCH_BIT.0;
2028            first = false;
2029        }
2030        if remaining & Self::DESCRIPTOR_HEAP.0 != 0 {
2031            if !first {
2032                f.write_str(" | ")?;
2033            }
2034            f.write_str("DESCRIPTOR_HEAP")?;
2035            remaining &= !Self::DESCRIPTOR_HEAP.0;
2036            first = false;
2037        }
2038        if remaining & Self::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0 != 0 {
2039            if !first {
2040                f.write_str(" | ")?;
2041            }
2042            f.write_str("ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY")?;
2043            remaining &= !Self::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0;
2044            first = false;
2045        }
2046        if remaining & Self::ACCELERATION_STRUCTURE_STORAGE.0 != 0 {
2047            if !first {
2048                f.write_str(" | ")?;
2049            }
2050            f.write_str("ACCELERATION_STRUCTURE_STORAGE")?;
2051            remaining &= !Self::ACCELERATION_STRUCTURE_STORAGE.0;
2052            first = false;
2053        }
2054        if remaining & Self::SHADER_BINDING_TABLE.0 != 0 {
2055            if !first {
2056                f.write_str(" | ")?;
2057            }
2058            f.write_str("SHADER_BINDING_TABLE")?;
2059            remaining &= !Self::SHADER_BINDING_TABLE.0;
2060            first = false;
2061        }
2062        if remaining & Self::VIDEO_ENCODE_DST.0 != 0 {
2063            if !first {
2064                f.write_str(" | ")?;
2065            }
2066            f.write_str("VIDEO_ENCODE_DST")?;
2067            remaining &= !Self::VIDEO_ENCODE_DST.0;
2068            first = false;
2069        }
2070        if remaining & Self::VIDEO_ENCODE_SRC.0 != 0 {
2071            if !first {
2072                f.write_str(" | ")?;
2073            }
2074            f.write_str("VIDEO_ENCODE_SRC")?;
2075            remaining &= !Self::VIDEO_ENCODE_SRC.0;
2076            first = false;
2077        }
2078        if remaining & Self::SAMPLER_DESCRIPTOR_BUFFER.0 != 0 {
2079            if !first {
2080                f.write_str(" | ")?;
2081            }
2082            f.write_str("SAMPLER_DESCRIPTOR_BUFFER")?;
2083            remaining &= !Self::SAMPLER_DESCRIPTOR_BUFFER.0;
2084            first = false;
2085        }
2086        if remaining & Self::RESOURCE_DESCRIPTOR_BUFFER.0 != 0 {
2087            if !first {
2088                f.write_str(" | ")?;
2089            }
2090            f.write_str("RESOURCE_DESCRIPTOR_BUFFER")?;
2091            remaining &= !Self::RESOURCE_DESCRIPTOR_BUFFER.0;
2092            first = false;
2093        }
2094        if remaining & Self::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0 != 0 {
2095            if !first {
2096                f.write_str(" | ")?;
2097            }
2098            f.write_str("PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER")?;
2099            remaining &= !Self::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0;
2100            first = false;
2101        }
2102        if remaining & Self::MICROMAP_BUILD_INPUT_READ_ONLY.0 != 0 {
2103            if !first {
2104                f.write_str(" | ")?;
2105            }
2106            f.write_str("MICROMAP_BUILD_INPUT_READ_ONLY")?;
2107            remaining &= !Self::MICROMAP_BUILD_INPUT_READ_ONLY.0;
2108            first = false;
2109        }
2110        if remaining & Self::MICROMAP_STORAGE.0 != 0 {
2111            if !first {
2112                f.write_str(" | ")?;
2113            }
2114            f.write_str("MICROMAP_STORAGE")?;
2115            remaining &= !Self::MICROMAP_STORAGE.0;
2116            first = false;
2117        }
2118        if remaining & Self::TILE_MEMORY_BIT.0 != 0 {
2119            if !first {
2120                f.write_str(" | ")?;
2121            }
2122            f.write_str("TILE_MEMORY_BIT")?;
2123            remaining &= !Self::TILE_MEMORY_BIT.0;
2124            first = false;
2125        }
2126        if remaining != 0u32 {
2127            if !first {
2128                f.write_str(" | ")?;
2129            }
2130            write!(f, "{:#x}", remaining)?;
2131        } else if first {
2132            f.write_str("(empty)")?;
2133        }
2134        Ok(())
2135    }
2136}
2137///[`VkBufferUsageFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits2.html)
2138#[repr(transparent)]
2139#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
2140#[doc(alias = "VkBufferUsageFlagBits2")]
2141pub struct BufferUsageFlagBits2(u64);
2142impl BufferUsageFlagBits2 {
2143    #[inline]
2144    pub const fn empty() -> Self {
2145        Self(0u64)
2146    }
2147    #[inline]
2148    pub const fn from_raw(value: u64) -> Self {
2149        Self(value)
2150    }
2151    #[inline]
2152    pub const fn as_raw(self) -> u64 {
2153        self.0
2154    }
2155    #[inline]
2156    pub const fn is_empty(self) -> bool {
2157        self.0 == 0u64
2158    }
2159    #[inline]
2160    pub const fn contains(self, other: Self) -> bool {
2161        (self.0 & other.0) == other.0
2162    }
2163    ///Bit 0.
2164    pub const _2_TRANSFER_SRC: Self = Self(1u64);
2165    ///Bit 1.
2166    pub const _2_TRANSFER_DST: Self = Self(2u64);
2167    ///Bit 2.
2168    pub const _2_UNIFORM_TEXEL_BUFFER: Self = Self(4u64);
2169    ///Bit 3.
2170    pub const _2_STORAGE_TEXEL_BUFFER: Self = Self(8u64);
2171    ///Bit 4.
2172    pub const _2_UNIFORM_BUFFER: Self = Self(16u64);
2173    ///Bit 5.
2174    pub const _2_STORAGE_BUFFER: Self = Self(32u64);
2175    ///Bit 6.
2176    pub const _2_INDEX_BUFFER: Self = Self(64u64);
2177    ///Bit 7.
2178    pub const _2_VERTEX_BUFFER: Self = Self(128u64);
2179    ///Bit 8.
2180    pub const _2_INDIRECT_BUFFER: Self = Self(256u64);
2181    ///Bit 17.
2182    pub const _2_SHADER_DEVICE_ADDRESS: Self = Self(131072u64);
2183    ///Bit 25.
2184    pub const _2_EXECUTION_GRAPH_SCRATCH_BIT: Self = Self(33554432u64);
2185    ///Bit 28.
2186    pub const _2_DESCRIPTOR_HEAP: Self = Self(268435456u64);
2187    ///Bit 9.
2188    pub const _2_CONDITIONAL_RENDERING: Self = Self(512u64);
2189    ///Bit 10.
2190    pub const _2_SHADER_BINDING_TABLE: Self = Self(1024u64);
2191    pub const _2_RAY_TRACING: Self = Self::_2_SHADER_BINDING_TABLE;
2192    ///Bit 11.
2193    pub const _2_TRANSFORM_FEEDBACK_BUFFER: Self = Self(2048u64);
2194    ///Bit 12.
2195    pub const _2_TRANSFORM_FEEDBACK_COUNTER_BUFFER: Self = Self(4096u64);
2196    ///Bit 13.
2197    pub const _2_VIDEO_DECODE_SRC: Self = Self(8192u64);
2198    ///Bit 14.
2199    pub const _2_VIDEO_DECODE_DST: Self = Self(16384u64);
2200    ///Bit 15.
2201    pub const _2_VIDEO_ENCODE_DST: Self = Self(32768u64);
2202    ///Bit 16.
2203    pub const _2_VIDEO_ENCODE_SRC: Self = Self(65536u64);
2204    ///Bit 19.
2205    pub const _2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY: Self = Self(524288u64);
2206    ///Bit 20.
2207    pub const _2_ACCELERATION_STRUCTURE_STORAGE: Self = Self(1048576u64);
2208    ///Bit 21.
2209    pub const _2_SAMPLER_DESCRIPTOR_BUFFER: Self = Self(2097152u64);
2210    ///Bit 22.
2211    pub const _2_RESOURCE_DESCRIPTOR_BUFFER: Self = Self(4194304u64);
2212    ///Bit 26.
2213    pub const _2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER: Self = Self(67108864u64);
2214    ///Bit 23.
2215    pub const _2_MICROMAP_BUILD_INPUT_READ_ONLY: Self = Self(8388608u64);
2216    ///Bit 24.
2217    pub const _2_MICROMAP_STORAGE: Self = Self(16777216u64);
2218    ///Bit 33.
2219    pub const _2_COMPRESSED_DATA_DGF1_BIT: Self = Self(8589934592u64);
2220    ///Bit 29.
2221    pub const _2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT: Self = Self(536870912u64);
2222    ///Bit 27.
2223    pub const _2_TILE_MEMORY_BIT: Self = Self(134217728u64);
2224    ///Bit 32.
2225    pub const _2_MEMORY_DECOMPRESSION: Self = Self(4294967296u64);
2226    ///Bit 31.
2227    pub const _2_PREPROCESS_BUFFER: Self = Self(2147483648u64);
2228}
2229impl core::ops::BitOr for BufferUsageFlagBits2 {
2230    type Output = Self;
2231    #[inline]
2232    fn bitor(self, rhs: Self) -> Self {
2233        Self(self.0 | rhs.0)
2234    }
2235}
2236impl core::ops::BitOrAssign for BufferUsageFlagBits2 {
2237    #[inline]
2238    fn bitor_assign(&mut self, rhs: Self) {
2239        self.0 |= rhs.0;
2240    }
2241}
2242impl core::ops::BitAnd for BufferUsageFlagBits2 {
2243    type Output = Self;
2244    #[inline]
2245    fn bitand(self, rhs: Self) -> Self {
2246        Self(self.0 & rhs.0)
2247    }
2248}
2249impl core::ops::BitAndAssign for BufferUsageFlagBits2 {
2250    #[inline]
2251    fn bitand_assign(&mut self, rhs: Self) {
2252        self.0 &= rhs.0;
2253    }
2254}
2255impl core::ops::BitXor for BufferUsageFlagBits2 {
2256    type Output = Self;
2257    #[inline]
2258    fn bitxor(self, rhs: Self) -> Self {
2259        Self(self.0 ^ rhs.0)
2260    }
2261}
2262impl core::ops::BitXorAssign for BufferUsageFlagBits2 {
2263    #[inline]
2264    fn bitxor_assign(&mut self, rhs: Self) {
2265        self.0 ^= rhs.0;
2266    }
2267}
2268impl core::ops::Not for BufferUsageFlagBits2 {
2269    type Output = Self;
2270    #[inline]
2271    fn not(self) -> Self {
2272        Self(!self.0)
2273    }
2274}
2275impl core::fmt::Debug for BufferUsageFlagBits2 {
2276    #[allow(unused_mut, unused_variables)]
2277    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2278        let mut first = true;
2279        let mut remaining = self.0;
2280        if remaining & Self::_2_TRANSFER_SRC.0 != 0 {
2281            if !first {
2282                f.write_str(" | ")?;
2283            }
2284            f.write_str("_2_TRANSFER_SRC")?;
2285            remaining &= !Self::_2_TRANSFER_SRC.0;
2286            first = false;
2287        }
2288        if remaining & Self::_2_TRANSFER_DST.0 != 0 {
2289            if !first {
2290                f.write_str(" | ")?;
2291            }
2292            f.write_str("_2_TRANSFER_DST")?;
2293            remaining &= !Self::_2_TRANSFER_DST.0;
2294            first = false;
2295        }
2296        if remaining & Self::_2_UNIFORM_TEXEL_BUFFER.0 != 0 {
2297            if !first {
2298                f.write_str(" | ")?;
2299            }
2300            f.write_str("_2_UNIFORM_TEXEL_BUFFER")?;
2301            remaining &= !Self::_2_UNIFORM_TEXEL_BUFFER.0;
2302            first = false;
2303        }
2304        if remaining & Self::_2_STORAGE_TEXEL_BUFFER.0 != 0 {
2305            if !first {
2306                f.write_str(" | ")?;
2307            }
2308            f.write_str("_2_STORAGE_TEXEL_BUFFER")?;
2309            remaining &= !Self::_2_STORAGE_TEXEL_BUFFER.0;
2310            first = false;
2311        }
2312        if remaining & Self::_2_UNIFORM_BUFFER.0 != 0 {
2313            if !first {
2314                f.write_str(" | ")?;
2315            }
2316            f.write_str("_2_UNIFORM_BUFFER")?;
2317            remaining &= !Self::_2_UNIFORM_BUFFER.0;
2318            first = false;
2319        }
2320        if remaining & Self::_2_STORAGE_BUFFER.0 != 0 {
2321            if !first {
2322                f.write_str(" | ")?;
2323            }
2324            f.write_str("_2_STORAGE_BUFFER")?;
2325            remaining &= !Self::_2_STORAGE_BUFFER.0;
2326            first = false;
2327        }
2328        if remaining & Self::_2_INDEX_BUFFER.0 != 0 {
2329            if !first {
2330                f.write_str(" | ")?;
2331            }
2332            f.write_str("_2_INDEX_BUFFER")?;
2333            remaining &= !Self::_2_INDEX_BUFFER.0;
2334            first = false;
2335        }
2336        if remaining & Self::_2_VERTEX_BUFFER.0 != 0 {
2337            if !first {
2338                f.write_str(" | ")?;
2339            }
2340            f.write_str("_2_VERTEX_BUFFER")?;
2341            remaining &= !Self::_2_VERTEX_BUFFER.0;
2342            first = false;
2343        }
2344        if remaining & Self::_2_INDIRECT_BUFFER.0 != 0 {
2345            if !first {
2346                f.write_str(" | ")?;
2347            }
2348            f.write_str("_2_INDIRECT_BUFFER")?;
2349            remaining &= !Self::_2_INDIRECT_BUFFER.0;
2350            first = false;
2351        }
2352        if remaining & Self::_2_SHADER_DEVICE_ADDRESS.0 != 0 {
2353            if !first {
2354                f.write_str(" | ")?;
2355            }
2356            f.write_str("_2_SHADER_DEVICE_ADDRESS")?;
2357            remaining &= !Self::_2_SHADER_DEVICE_ADDRESS.0;
2358            first = false;
2359        }
2360        if remaining & Self::_2_EXECUTION_GRAPH_SCRATCH_BIT.0 != 0 {
2361            if !first {
2362                f.write_str(" | ")?;
2363            }
2364            f.write_str("_2_EXECUTION_GRAPH_SCRATCH_BIT")?;
2365            remaining &= !Self::_2_EXECUTION_GRAPH_SCRATCH_BIT.0;
2366            first = false;
2367        }
2368        if remaining & Self::_2_DESCRIPTOR_HEAP.0 != 0 {
2369            if !first {
2370                f.write_str(" | ")?;
2371            }
2372            f.write_str("_2_DESCRIPTOR_HEAP")?;
2373            remaining &= !Self::_2_DESCRIPTOR_HEAP.0;
2374            first = false;
2375        }
2376        if remaining & Self::_2_CONDITIONAL_RENDERING.0 != 0 {
2377            if !first {
2378                f.write_str(" | ")?;
2379            }
2380            f.write_str("_2_CONDITIONAL_RENDERING")?;
2381            remaining &= !Self::_2_CONDITIONAL_RENDERING.0;
2382            first = false;
2383        }
2384        if remaining & Self::_2_SHADER_BINDING_TABLE.0 != 0 {
2385            if !first {
2386                f.write_str(" | ")?;
2387            }
2388            f.write_str("_2_SHADER_BINDING_TABLE")?;
2389            remaining &= !Self::_2_SHADER_BINDING_TABLE.0;
2390            first = false;
2391        }
2392        if remaining & Self::_2_TRANSFORM_FEEDBACK_BUFFER.0 != 0 {
2393            if !first {
2394                f.write_str(" | ")?;
2395            }
2396            f.write_str("_2_TRANSFORM_FEEDBACK_BUFFER")?;
2397            remaining &= !Self::_2_TRANSFORM_FEEDBACK_BUFFER.0;
2398            first = false;
2399        }
2400        if remaining & Self::_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER.0 != 0 {
2401            if !first {
2402                f.write_str(" | ")?;
2403            }
2404            f.write_str("_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER")?;
2405            remaining &= !Self::_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER.0;
2406            first = false;
2407        }
2408        if remaining & Self::_2_VIDEO_DECODE_SRC.0 != 0 {
2409            if !first {
2410                f.write_str(" | ")?;
2411            }
2412            f.write_str("_2_VIDEO_DECODE_SRC")?;
2413            remaining &= !Self::_2_VIDEO_DECODE_SRC.0;
2414            first = false;
2415        }
2416        if remaining & Self::_2_VIDEO_DECODE_DST.0 != 0 {
2417            if !first {
2418                f.write_str(" | ")?;
2419            }
2420            f.write_str("_2_VIDEO_DECODE_DST")?;
2421            remaining &= !Self::_2_VIDEO_DECODE_DST.0;
2422            first = false;
2423        }
2424        if remaining & Self::_2_VIDEO_ENCODE_DST.0 != 0 {
2425            if !first {
2426                f.write_str(" | ")?;
2427            }
2428            f.write_str("_2_VIDEO_ENCODE_DST")?;
2429            remaining &= !Self::_2_VIDEO_ENCODE_DST.0;
2430            first = false;
2431        }
2432        if remaining & Self::_2_VIDEO_ENCODE_SRC.0 != 0 {
2433            if !first {
2434                f.write_str(" | ")?;
2435            }
2436            f.write_str("_2_VIDEO_ENCODE_SRC")?;
2437            remaining &= !Self::_2_VIDEO_ENCODE_SRC.0;
2438            first = false;
2439        }
2440        if remaining & Self::_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0 != 0 {
2441            if !first {
2442                f.write_str(" | ")?;
2443            }
2444            f.write_str("_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY")?;
2445            remaining &= !Self::_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0;
2446            first = false;
2447        }
2448        if remaining & Self::_2_ACCELERATION_STRUCTURE_STORAGE.0 != 0 {
2449            if !first {
2450                f.write_str(" | ")?;
2451            }
2452            f.write_str("_2_ACCELERATION_STRUCTURE_STORAGE")?;
2453            remaining &= !Self::_2_ACCELERATION_STRUCTURE_STORAGE.0;
2454            first = false;
2455        }
2456        if remaining & Self::_2_SAMPLER_DESCRIPTOR_BUFFER.0 != 0 {
2457            if !first {
2458                f.write_str(" | ")?;
2459            }
2460            f.write_str("_2_SAMPLER_DESCRIPTOR_BUFFER")?;
2461            remaining &= !Self::_2_SAMPLER_DESCRIPTOR_BUFFER.0;
2462            first = false;
2463        }
2464        if remaining & Self::_2_RESOURCE_DESCRIPTOR_BUFFER.0 != 0 {
2465            if !first {
2466                f.write_str(" | ")?;
2467            }
2468            f.write_str("_2_RESOURCE_DESCRIPTOR_BUFFER")?;
2469            remaining &= !Self::_2_RESOURCE_DESCRIPTOR_BUFFER.0;
2470            first = false;
2471        }
2472        if remaining & Self::_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0 != 0 {
2473            if !first {
2474                f.write_str(" | ")?;
2475            }
2476            f.write_str("_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER")?;
2477            remaining &= !Self::_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0;
2478            first = false;
2479        }
2480        if remaining & Self::_2_MICROMAP_BUILD_INPUT_READ_ONLY.0 != 0 {
2481            if !first {
2482                f.write_str(" | ")?;
2483            }
2484            f.write_str("_2_MICROMAP_BUILD_INPUT_READ_ONLY")?;
2485            remaining &= !Self::_2_MICROMAP_BUILD_INPUT_READ_ONLY.0;
2486            first = false;
2487        }
2488        if remaining & Self::_2_MICROMAP_STORAGE.0 != 0 {
2489            if !first {
2490                f.write_str(" | ")?;
2491            }
2492            f.write_str("_2_MICROMAP_STORAGE")?;
2493            remaining &= !Self::_2_MICROMAP_STORAGE.0;
2494            first = false;
2495        }
2496        if remaining & Self::_2_COMPRESSED_DATA_DGF1_BIT.0 != 0 {
2497            if !first {
2498                f.write_str(" | ")?;
2499            }
2500            f.write_str("_2_COMPRESSED_DATA_DGF1_BIT")?;
2501            remaining &= !Self::_2_COMPRESSED_DATA_DGF1_BIT.0;
2502            first = false;
2503        }
2504        if remaining & Self::_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT.0 != 0 {
2505            if !first {
2506                f.write_str(" | ")?;
2507            }
2508            f.write_str("_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT")?;
2509            remaining &= !Self::_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT.0;
2510            first = false;
2511        }
2512        if remaining & Self::_2_TILE_MEMORY_BIT.0 != 0 {
2513            if !first {
2514                f.write_str(" | ")?;
2515            }
2516            f.write_str("_2_TILE_MEMORY_BIT")?;
2517            remaining &= !Self::_2_TILE_MEMORY_BIT.0;
2518            first = false;
2519        }
2520        if remaining & Self::_2_MEMORY_DECOMPRESSION.0 != 0 {
2521            if !first {
2522                f.write_str(" | ")?;
2523            }
2524            f.write_str("_2_MEMORY_DECOMPRESSION")?;
2525            remaining &= !Self::_2_MEMORY_DECOMPRESSION.0;
2526            first = false;
2527        }
2528        if remaining & Self::_2_PREPROCESS_BUFFER.0 != 0 {
2529            if !first {
2530                f.write_str(" | ")?;
2531            }
2532            f.write_str("_2_PREPROCESS_BUFFER")?;
2533            remaining &= !Self::_2_PREPROCESS_BUFFER.0;
2534            first = false;
2535        }
2536        if remaining != 0u64 {
2537            if !first {
2538                f.write_str(" | ")?;
2539            }
2540            write!(f, "{:#x}", remaining)?;
2541        } else if first {
2542            f.write_str("(empty)")?;
2543        }
2544        Ok(())
2545    }
2546}
2547///[`VkBuildAccelerationStructureFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureFlagBitsKHR.html)
2548#[repr(transparent)]
2549#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
2550#[doc(alias = "VkBuildAccelerationStructureFlagBitsKHR")]
2551pub struct BuildAccelerationStructureFlagBitsKHR(u32);
2552impl BuildAccelerationStructureFlagBitsKHR {
2553    #[inline]
2554    pub const fn empty() -> Self {
2555        Self(0u32)
2556    }
2557    #[inline]
2558    pub const fn from_raw(value: u32) -> Self {
2559        Self(value)
2560    }
2561    #[inline]
2562    pub const fn as_raw(self) -> u32 {
2563        self.0
2564    }
2565    #[inline]
2566    pub const fn is_empty(self) -> bool {
2567        self.0 == 0u32
2568    }
2569    #[inline]
2570    pub const fn contains(self, other: Self) -> bool {
2571        (self.0 & other.0) == other.0
2572    }
2573    ///Bit 0.
2574    pub const ALLOW_UPDATE: Self = Self(1u32);
2575    ///Bit 1.
2576    pub const ALLOW_COMPACTION: Self = Self(2u32);
2577    ///Bit 2.
2578    pub const PREFER_FAST_TRACE: Self = Self(4u32);
2579    ///Bit 3.
2580    pub const PREFER_FAST_BUILD: Self = Self(8u32);
2581    ///Bit 4.
2582    pub const LOW_MEMORY: Self = Self(16u32);
2583    ///Bit 5.
2584    pub const MOTION: Self = Self(32u32);
2585    ///Bit 6.
2586    pub const ALLOW_OPACITY_MICROMAP_UPDATE: Self = Self(64u32);
2587    ///Bit 7.
2588    pub const ALLOW_DISABLE_OPACITY_MICROMAPS: Self = Self(128u32);
2589    ///Bit 8.
2590    pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE: Self = Self(256u32);
2591    ///Bit 9.
2592    pub const ALLOW_DISPLACEMENT_MICROMAP_UPDATE: Self = Self(512u32);
2593    ///Bit 11.
2594    pub const ALLOW_DATA_ACCESS: Self = Self(2048u32);
2595    ///Bit 12.
2596    pub const ALLOW_CLUSTER_OPACITY_MICROMAPS: Self = Self(4096u32);
2597}
2598impl core::ops::BitOr for BuildAccelerationStructureFlagBitsKHR {
2599    type Output = Self;
2600    #[inline]
2601    fn bitor(self, rhs: Self) -> Self {
2602        Self(self.0 | rhs.0)
2603    }
2604}
2605impl core::ops::BitOrAssign for BuildAccelerationStructureFlagBitsKHR {
2606    #[inline]
2607    fn bitor_assign(&mut self, rhs: Self) {
2608        self.0 |= rhs.0;
2609    }
2610}
2611impl core::ops::BitAnd for BuildAccelerationStructureFlagBitsKHR {
2612    type Output = Self;
2613    #[inline]
2614    fn bitand(self, rhs: Self) -> Self {
2615        Self(self.0 & rhs.0)
2616    }
2617}
2618impl core::ops::BitAndAssign for BuildAccelerationStructureFlagBitsKHR {
2619    #[inline]
2620    fn bitand_assign(&mut self, rhs: Self) {
2621        self.0 &= rhs.0;
2622    }
2623}
2624impl core::ops::BitXor for BuildAccelerationStructureFlagBitsKHR {
2625    type Output = Self;
2626    #[inline]
2627    fn bitxor(self, rhs: Self) -> Self {
2628        Self(self.0 ^ rhs.0)
2629    }
2630}
2631impl core::ops::BitXorAssign for BuildAccelerationStructureFlagBitsKHR {
2632    #[inline]
2633    fn bitxor_assign(&mut self, rhs: Self) {
2634        self.0 ^= rhs.0;
2635    }
2636}
2637impl core::ops::Not for BuildAccelerationStructureFlagBitsKHR {
2638    type Output = Self;
2639    #[inline]
2640    fn not(self) -> Self {
2641        Self(!self.0)
2642    }
2643}
2644impl core::fmt::Debug for BuildAccelerationStructureFlagBitsKHR {
2645    #[allow(unused_mut, unused_variables)]
2646    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2647        let mut first = true;
2648        let mut remaining = self.0;
2649        if remaining & Self::ALLOW_UPDATE.0 != 0 {
2650            if !first {
2651                f.write_str(" | ")?;
2652            }
2653            f.write_str("ALLOW_UPDATE")?;
2654            remaining &= !Self::ALLOW_UPDATE.0;
2655            first = false;
2656        }
2657        if remaining & Self::ALLOW_COMPACTION.0 != 0 {
2658            if !first {
2659                f.write_str(" | ")?;
2660            }
2661            f.write_str("ALLOW_COMPACTION")?;
2662            remaining &= !Self::ALLOW_COMPACTION.0;
2663            first = false;
2664        }
2665        if remaining & Self::PREFER_FAST_TRACE.0 != 0 {
2666            if !first {
2667                f.write_str(" | ")?;
2668            }
2669            f.write_str("PREFER_FAST_TRACE")?;
2670            remaining &= !Self::PREFER_FAST_TRACE.0;
2671            first = false;
2672        }
2673        if remaining & Self::PREFER_FAST_BUILD.0 != 0 {
2674            if !first {
2675                f.write_str(" | ")?;
2676            }
2677            f.write_str("PREFER_FAST_BUILD")?;
2678            remaining &= !Self::PREFER_FAST_BUILD.0;
2679            first = false;
2680        }
2681        if remaining & Self::LOW_MEMORY.0 != 0 {
2682            if !first {
2683                f.write_str(" | ")?;
2684            }
2685            f.write_str("LOW_MEMORY")?;
2686            remaining &= !Self::LOW_MEMORY.0;
2687            first = false;
2688        }
2689        if remaining & Self::MOTION.0 != 0 {
2690            if !first {
2691                f.write_str(" | ")?;
2692            }
2693            f.write_str("MOTION")?;
2694            remaining &= !Self::MOTION.0;
2695            first = false;
2696        }
2697        if remaining & Self::ALLOW_OPACITY_MICROMAP_UPDATE.0 != 0 {
2698            if !first {
2699                f.write_str(" | ")?;
2700            }
2701            f.write_str("ALLOW_OPACITY_MICROMAP_UPDATE")?;
2702            remaining &= !Self::ALLOW_OPACITY_MICROMAP_UPDATE.0;
2703            first = false;
2704        }
2705        if remaining & Self::ALLOW_DISABLE_OPACITY_MICROMAPS.0 != 0 {
2706            if !first {
2707                f.write_str(" | ")?;
2708            }
2709            f.write_str("ALLOW_DISABLE_OPACITY_MICROMAPS")?;
2710            remaining &= !Self::ALLOW_DISABLE_OPACITY_MICROMAPS.0;
2711            first = false;
2712        }
2713        if remaining & Self::ALLOW_OPACITY_MICROMAP_DATA_UPDATE.0 != 0 {
2714            if !first {
2715                f.write_str(" | ")?;
2716            }
2717            f.write_str("ALLOW_OPACITY_MICROMAP_DATA_UPDATE")?;
2718            remaining &= !Self::ALLOW_OPACITY_MICROMAP_DATA_UPDATE.0;
2719            first = false;
2720        }
2721        if remaining & Self::ALLOW_DISPLACEMENT_MICROMAP_UPDATE.0 != 0 {
2722            if !first {
2723                f.write_str(" | ")?;
2724            }
2725            f.write_str("ALLOW_DISPLACEMENT_MICROMAP_UPDATE")?;
2726            remaining &= !Self::ALLOW_DISPLACEMENT_MICROMAP_UPDATE.0;
2727            first = false;
2728        }
2729        if remaining & Self::ALLOW_DATA_ACCESS.0 != 0 {
2730            if !first {
2731                f.write_str(" | ")?;
2732            }
2733            f.write_str("ALLOW_DATA_ACCESS")?;
2734            remaining &= !Self::ALLOW_DATA_ACCESS.0;
2735            first = false;
2736        }
2737        if remaining & Self::ALLOW_CLUSTER_OPACITY_MICROMAPS.0 != 0 {
2738            if !first {
2739                f.write_str(" | ")?;
2740            }
2741            f.write_str("ALLOW_CLUSTER_OPACITY_MICROMAPS")?;
2742            remaining &= !Self::ALLOW_CLUSTER_OPACITY_MICROMAPS.0;
2743            first = false;
2744        }
2745        if remaining != 0u32 {
2746            if !first {
2747                f.write_str(" | ")?;
2748            }
2749            write!(f, "{:#x}", remaining)?;
2750        } else if first {
2751            f.write_str("(empty)")?;
2752        }
2753        Ok(())
2754    }
2755}
2756///[`VkBuildMicromapFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapFlagBitsEXT.html)
2757#[repr(transparent)]
2758#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
2759#[doc(alias = "VkBuildMicromapFlagBitsEXT")]
2760pub struct BuildMicromapFlagBitsEXT(u32);
2761impl BuildMicromapFlagBitsEXT {
2762    #[inline]
2763    pub const fn empty() -> Self {
2764        Self(0u32)
2765    }
2766    #[inline]
2767    pub const fn from_raw(value: u32) -> Self {
2768        Self(value)
2769    }
2770    #[inline]
2771    pub const fn as_raw(self) -> u32 {
2772        self.0
2773    }
2774    #[inline]
2775    pub const fn is_empty(self) -> bool {
2776        self.0 == 0u32
2777    }
2778    #[inline]
2779    pub const fn contains(self, other: Self) -> bool {
2780        (self.0 & other.0) == other.0
2781    }
2782    ///Bit 0.
2783    pub const PREFER_FAST_TRACE: Self = Self(1u32);
2784    ///Bit 1.
2785    pub const PREFER_FAST_BUILD: Self = Self(2u32);
2786    ///Bit 2.
2787    pub const ALLOW_COMPACTION: Self = Self(4u32);
2788}
2789impl core::ops::BitOr for BuildMicromapFlagBitsEXT {
2790    type Output = Self;
2791    #[inline]
2792    fn bitor(self, rhs: Self) -> Self {
2793        Self(self.0 | rhs.0)
2794    }
2795}
2796impl core::ops::BitOrAssign for BuildMicromapFlagBitsEXT {
2797    #[inline]
2798    fn bitor_assign(&mut self, rhs: Self) {
2799        self.0 |= rhs.0;
2800    }
2801}
2802impl core::ops::BitAnd for BuildMicromapFlagBitsEXT {
2803    type Output = Self;
2804    #[inline]
2805    fn bitand(self, rhs: Self) -> Self {
2806        Self(self.0 & rhs.0)
2807    }
2808}
2809impl core::ops::BitAndAssign for BuildMicromapFlagBitsEXT {
2810    #[inline]
2811    fn bitand_assign(&mut self, rhs: Self) {
2812        self.0 &= rhs.0;
2813    }
2814}
2815impl core::ops::BitXor for BuildMicromapFlagBitsEXT {
2816    type Output = Self;
2817    #[inline]
2818    fn bitxor(self, rhs: Self) -> Self {
2819        Self(self.0 ^ rhs.0)
2820    }
2821}
2822impl core::ops::BitXorAssign for BuildMicromapFlagBitsEXT {
2823    #[inline]
2824    fn bitxor_assign(&mut self, rhs: Self) {
2825        self.0 ^= rhs.0;
2826    }
2827}
2828impl core::ops::Not for BuildMicromapFlagBitsEXT {
2829    type Output = Self;
2830    #[inline]
2831    fn not(self) -> Self {
2832        Self(!self.0)
2833    }
2834}
2835impl core::fmt::Debug for BuildMicromapFlagBitsEXT {
2836    #[allow(unused_mut, unused_variables)]
2837    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2838        let mut first = true;
2839        let mut remaining = self.0;
2840        if remaining & Self::PREFER_FAST_TRACE.0 != 0 {
2841            if !first {
2842                f.write_str(" | ")?;
2843            }
2844            f.write_str("PREFER_FAST_TRACE")?;
2845            remaining &= !Self::PREFER_FAST_TRACE.0;
2846            first = false;
2847        }
2848        if remaining & Self::PREFER_FAST_BUILD.0 != 0 {
2849            if !first {
2850                f.write_str(" | ")?;
2851            }
2852            f.write_str("PREFER_FAST_BUILD")?;
2853            remaining &= !Self::PREFER_FAST_BUILD.0;
2854            first = false;
2855        }
2856        if remaining & Self::ALLOW_COMPACTION.0 != 0 {
2857            if !first {
2858                f.write_str(" | ")?;
2859            }
2860            f.write_str("ALLOW_COMPACTION")?;
2861            remaining &= !Self::ALLOW_COMPACTION.0;
2862            first = false;
2863        }
2864        if remaining != 0u32 {
2865            if !first {
2866                f.write_str(" | ")?;
2867            }
2868            write!(f, "{:#x}", remaining)?;
2869        } else if first {
2870            f.write_str("(empty)")?;
2871        }
2872        Ok(())
2873    }
2874}
2875///[`VkClusterAccelerationStructureAddressResolutionFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureAddressResolutionFlagBitsNV.html)
2876#[repr(transparent)]
2877#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
2878#[doc(alias = "VkClusterAccelerationStructureAddressResolutionFlagBitsNV")]
2879pub struct ClusterAccelerationStructureAddressResolutionFlagBitsNV(u32);
2880impl ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2881    #[inline]
2882    pub const fn empty() -> Self {
2883        Self(0u32)
2884    }
2885    #[inline]
2886    pub const fn from_raw(value: u32) -> Self {
2887        Self(value)
2888    }
2889    #[inline]
2890    pub const fn as_raw(self) -> u32 {
2891        self.0
2892    }
2893    #[inline]
2894    pub const fn is_empty(self) -> bool {
2895        self.0 == 0u32
2896    }
2897    #[inline]
2898    pub const fn contains(self, other: Self) -> bool {
2899        (self.0 & other.0) == other.0
2900    }
2901    pub const NONE: Self = Self(0u32);
2902    ///Bit 0.
2903    pub const INDIRECTED_DST_IMPLICIT_DATA: Self = Self(1u32);
2904    ///Bit 1.
2905    pub const INDIRECTED_SCRATCH_DATA: Self = Self(2u32);
2906    ///Bit 2.
2907    pub const INDIRECTED_DST_ADDRESS_ARRAY: Self = Self(4u32);
2908    ///Bit 3.
2909    pub const INDIRECTED_DST_SIZES_ARRAY: Self = Self(8u32);
2910    ///Bit 4.
2911    pub const INDIRECTED_SRC_INFOS_ARRAY: Self = Self(16u32);
2912    ///Bit 5.
2913    pub const INDIRECTED_SRC_INFOS_COUNT: Self = Self(32u32);
2914}
2915impl core::ops::BitOr for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2916    type Output = Self;
2917    #[inline]
2918    fn bitor(self, rhs: Self) -> Self {
2919        Self(self.0 | rhs.0)
2920    }
2921}
2922impl core::ops::BitOrAssign for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2923    #[inline]
2924    fn bitor_assign(&mut self, rhs: Self) {
2925        self.0 |= rhs.0;
2926    }
2927}
2928impl core::ops::BitAnd for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2929    type Output = Self;
2930    #[inline]
2931    fn bitand(self, rhs: Self) -> Self {
2932        Self(self.0 & rhs.0)
2933    }
2934}
2935impl core::ops::BitAndAssign
2936for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2937    #[inline]
2938    fn bitand_assign(&mut self, rhs: Self) {
2939        self.0 &= rhs.0;
2940    }
2941}
2942impl core::ops::BitXor for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2943    type Output = Self;
2944    #[inline]
2945    fn bitxor(self, rhs: Self) -> Self {
2946        Self(self.0 ^ rhs.0)
2947    }
2948}
2949impl core::ops::BitXorAssign
2950for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2951    #[inline]
2952    fn bitxor_assign(&mut self, rhs: Self) {
2953        self.0 ^= rhs.0;
2954    }
2955}
2956impl core::ops::Not for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2957    type Output = Self;
2958    #[inline]
2959    fn not(self) -> Self {
2960        Self(!self.0)
2961    }
2962}
2963impl core::fmt::Debug for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
2964    #[allow(unused_mut, unused_variables)]
2965    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2966        let mut first = true;
2967        let mut remaining = self.0;
2968        if remaining & Self::INDIRECTED_DST_IMPLICIT_DATA.0 != 0 {
2969            if !first {
2970                f.write_str(" | ")?;
2971            }
2972            f.write_str("INDIRECTED_DST_IMPLICIT_DATA")?;
2973            remaining &= !Self::INDIRECTED_DST_IMPLICIT_DATA.0;
2974            first = false;
2975        }
2976        if remaining & Self::INDIRECTED_SCRATCH_DATA.0 != 0 {
2977            if !first {
2978                f.write_str(" | ")?;
2979            }
2980            f.write_str("INDIRECTED_SCRATCH_DATA")?;
2981            remaining &= !Self::INDIRECTED_SCRATCH_DATA.0;
2982            first = false;
2983        }
2984        if remaining & Self::INDIRECTED_DST_ADDRESS_ARRAY.0 != 0 {
2985            if !first {
2986                f.write_str(" | ")?;
2987            }
2988            f.write_str("INDIRECTED_DST_ADDRESS_ARRAY")?;
2989            remaining &= !Self::INDIRECTED_DST_ADDRESS_ARRAY.0;
2990            first = false;
2991        }
2992        if remaining & Self::INDIRECTED_DST_SIZES_ARRAY.0 != 0 {
2993            if !first {
2994                f.write_str(" | ")?;
2995            }
2996            f.write_str("INDIRECTED_DST_SIZES_ARRAY")?;
2997            remaining &= !Self::INDIRECTED_DST_SIZES_ARRAY.0;
2998            first = false;
2999        }
3000        if remaining & Self::INDIRECTED_SRC_INFOS_ARRAY.0 != 0 {
3001            if !first {
3002                f.write_str(" | ")?;
3003            }
3004            f.write_str("INDIRECTED_SRC_INFOS_ARRAY")?;
3005            remaining &= !Self::INDIRECTED_SRC_INFOS_ARRAY.0;
3006            first = false;
3007        }
3008        if remaining & Self::INDIRECTED_SRC_INFOS_COUNT.0 != 0 {
3009            if !first {
3010                f.write_str(" | ")?;
3011            }
3012            f.write_str("INDIRECTED_SRC_INFOS_COUNT")?;
3013            remaining &= !Self::INDIRECTED_SRC_INFOS_COUNT.0;
3014            first = false;
3015        }
3016        if remaining != 0u32 {
3017            if !first {
3018                f.write_str(" | ")?;
3019            }
3020            write!(f, "{:#x}", remaining)?;
3021        } else if first {
3022            f.write_str("(empty)")?;
3023        }
3024        Ok(())
3025    }
3026}
3027///[`VkClusterAccelerationStructureClusterFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClusterFlagBitsNV.html)
3028#[repr(transparent)]
3029#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3030#[doc(alias = "VkClusterAccelerationStructureClusterFlagBitsNV")]
3031pub struct ClusterAccelerationStructureClusterFlagBitsNV(u32);
3032impl ClusterAccelerationStructureClusterFlagBitsNV {
3033    #[inline]
3034    pub const fn empty() -> Self {
3035        Self(0u32)
3036    }
3037    #[inline]
3038    pub const fn from_raw(value: u32) -> Self {
3039        Self(value)
3040    }
3041    #[inline]
3042    pub const fn as_raw(self) -> u32 {
3043        self.0
3044    }
3045    #[inline]
3046    pub const fn is_empty(self) -> bool {
3047        self.0 == 0u32
3048    }
3049    #[inline]
3050    pub const fn contains(self, other: Self) -> bool {
3051        (self.0 & other.0) == other.0
3052    }
3053    ///Bit 0.
3054    pub const ALLOW_DISABLE_OPACITY_MICROMAPS: Self = Self(1u32);
3055}
3056impl core::ops::BitOr for ClusterAccelerationStructureClusterFlagBitsNV {
3057    type Output = Self;
3058    #[inline]
3059    fn bitor(self, rhs: Self) -> Self {
3060        Self(self.0 | rhs.0)
3061    }
3062}
3063impl core::ops::BitOrAssign for ClusterAccelerationStructureClusterFlagBitsNV {
3064    #[inline]
3065    fn bitor_assign(&mut self, rhs: Self) {
3066        self.0 |= rhs.0;
3067    }
3068}
3069impl core::ops::BitAnd for ClusterAccelerationStructureClusterFlagBitsNV {
3070    type Output = Self;
3071    #[inline]
3072    fn bitand(self, rhs: Self) -> Self {
3073        Self(self.0 & rhs.0)
3074    }
3075}
3076impl core::ops::BitAndAssign for ClusterAccelerationStructureClusterFlagBitsNV {
3077    #[inline]
3078    fn bitand_assign(&mut self, rhs: Self) {
3079        self.0 &= rhs.0;
3080    }
3081}
3082impl core::ops::BitXor for ClusterAccelerationStructureClusterFlagBitsNV {
3083    type Output = Self;
3084    #[inline]
3085    fn bitxor(self, rhs: Self) -> Self {
3086        Self(self.0 ^ rhs.0)
3087    }
3088}
3089impl core::ops::BitXorAssign for ClusterAccelerationStructureClusterFlagBitsNV {
3090    #[inline]
3091    fn bitxor_assign(&mut self, rhs: Self) {
3092        self.0 ^= rhs.0;
3093    }
3094}
3095impl core::ops::Not for ClusterAccelerationStructureClusterFlagBitsNV {
3096    type Output = Self;
3097    #[inline]
3098    fn not(self) -> Self {
3099        Self(!self.0)
3100    }
3101}
3102impl core::fmt::Debug for ClusterAccelerationStructureClusterFlagBitsNV {
3103    #[allow(unused_mut, unused_variables)]
3104    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3105        let mut first = true;
3106        let mut remaining = self.0;
3107        if remaining & Self::ALLOW_DISABLE_OPACITY_MICROMAPS.0 != 0 {
3108            if !first {
3109                f.write_str(" | ")?;
3110            }
3111            f.write_str("ALLOW_DISABLE_OPACITY_MICROMAPS")?;
3112            remaining &= !Self::ALLOW_DISABLE_OPACITY_MICROMAPS.0;
3113            first = false;
3114        }
3115        if remaining != 0u32 {
3116            if !first {
3117                f.write_str(" | ")?;
3118            }
3119            write!(f, "{:#x}", remaining)?;
3120        } else if first {
3121            f.write_str("(empty)")?;
3122        }
3123        Ok(())
3124    }
3125}
3126///[`VkClusterAccelerationStructureGeometryFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryFlagBitsNV.html)
3127#[repr(transparent)]
3128#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3129#[doc(alias = "VkClusterAccelerationStructureGeometryFlagBitsNV")]
3130pub struct ClusterAccelerationStructureGeometryFlagBitsNV(u32);
3131impl ClusterAccelerationStructureGeometryFlagBitsNV {
3132    #[inline]
3133    pub const fn empty() -> Self {
3134        Self(0u32)
3135    }
3136    #[inline]
3137    pub const fn from_raw(value: u32) -> Self {
3138        Self(value)
3139    }
3140    #[inline]
3141    pub const fn as_raw(self) -> u32 {
3142        self.0
3143    }
3144    #[inline]
3145    pub const fn is_empty(self) -> bool {
3146        self.0 == 0u32
3147    }
3148    #[inline]
3149    pub const fn contains(self, other: Self) -> bool {
3150        (self.0 & other.0) == other.0
3151    }
3152    ///Bit 0.
3153    pub const CULL_DISABLE: Self = Self(1u32);
3154    ///Bit 1.
3155    pub const NO_DUPLICATE_ANYHIT_INVOCATION: Self = Self(2u32);
3156    ///Bit 2.
3157    pub const OPAQUE: Self = Self(4u32);
3158}
3159impl core::ops::BitOr for ClusterAccelerationStructureGeometryFlagBitsNV {
3160    type Output = Self;
3161    #[inline]
3162    fn bitor(self, rhs: Self) -> Self {
3163        Self(self.0 | rhs.0)
3164    }
3165}
3166impl core::ops::BitOrAssign for ClusterAccelerationStructureGeometryFlagBitsNV {
3167    #[inline]
3168    fn bitor_assign(&mut self, rhs: Self) {
3169        self.0 |= rhs.0;
3170    }
3171}
3172impl core::ops::BitAnd for ClusterAccelerationStructureGeometryFlagBitsNV {
3173    type Output = Self;
3174    #[inline]
3175    fn bitand(self, rhs: Self) -> Self {
3176        Self(self.0 & rhs.0)
3177    }
3178}
3179impl core::ops::BitAndAssign for ClusterAccelerationStructureGeometryFlagBitsNV {
3180    #[inline]
3181    fn bitand_assign(&mut self, rhs: Self) {
3182        self.0 &= rhs.0;
3183    }
3184}
3185impl core::ops::BitXor for ClusterAccelerationStructureGeometryFlagBitsNV {
3186    type Output = Self;
3187    #[inline]
3188    fn bitxor(self, rhs: Self) -> Self {
3189        Self(self.0 ^ rhs.0)
3190    }
3191}
3192impl core::ops::BitXorAssign for ClusterAccelerationStructureGeometryFlagBitsNV {
3193    #[inline]
3194    fn bitxor_assign(&mut self, rhs: Self) {
3195        self.0 ^= rhs.0;
3196    }
3197}
3198impl core::ops::Not for ClusterAccelerationStructureGeometryFlagBitsNV {
3199    type Output = Self;
3200    #[inline]
3201    fn not(self) -> Self {
3202        Self(!self.0)
3203    }
3204}
3205impl core::fmt::Debug for ClusterAccelerationStructureGeometryFlagBitsNV {
3206    #[allow(unused_mut, unused_variables)]
3207    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3208        let mut first = true;
3209        let mut remaining = self.0;
3210        if remaining & Self::CULL_DISABLE.0 != 0 {
3211            if !first {
3212                f.write_str(" | ")?;
3213            }
3214            f.write_str("CULL_DISABLE")?;
3215            remaining &= !Self::CULL_DISABLE.0;
3216            first = false;
3217        }
3218        if remaining & Self::NO_DUPLICATE_ANYHIT_INVOCATION.0 != 0 {
3219            if !first {
3220                f.write_str(" | ")?;
3221            }
3222            f.write_str("NO_DUPLICATE_ANYHIT_INVOCATION")?;
3223            remaining &= !Self::NO_DUPLICATE_ANYHIT_INVOCATION.0;
3224            first = false;
3225        }
3226        if remaining & Self::OPAQUE.0 != 0 {
3227            if !first {
3228                f.write_str(" | ")?;
3229            }
3230            f.write_str("OPAQUE")?;
3231            remaining &= !Self::OPAQUE.0;
3232            first = false;
3233        }
3234        if remaining != 0u32 {
3235            if !first {
3236                f.write_str(" | ")?;
3237            }
3238            write!(f, "{:#x}", remaining)?;
3239        } else if first {
3240            f.write_str("(empty)")?;
3241        }
3242        Ok(())
3243    }
3244}
3245///[`VkClusterAccelerationStructureIndexFormatFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureIndexFormatFlagBitsNV.html)
3246#[repr(transparent)]
3247#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3248#[doc(alias = "VkClusterAccelerationStructureIndexFormatFlagBitsNV")]
3249pub struct ClusterAccelerationStructureIndexFormatFlagBitsNV(u32);
3250impl ClusterAccelerationStructureIndexFormatFlagBitsNV {
3251    #[inline]
3252    pub const fn empty() -> Self {
3253        Self(0u32)
3254    }
3255    #[inline]
3256    pub const fn from_raw(value: u32) -> Self {
3257        Self(value)
3258    }
3259    #[inline]
3260    pub const fn as_raw(self) -> u32 {
3261        self.0
3262    }
3263    #[inline]
3264    pub const fn is_empty(self) -> bool {
3265        self.0 == 0u32
3266    }
3267    #[inline]
3268    pub const fn contains(self, other: Self) -> bool {
3269        (self.0 & other.0) == other.0
3270    }
3271    ///Bit 0.
3272    pub const _8BIT: Self = Self(1u32);
3273    ///Bit 1.
3274    pub const _16BIT: Self = Self(2u32);
3275    ///Bit 2.
3276    pub const _32BIT: Self = Self(4u32);
3277}
3278impl core::ops::BitOr for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3279    type Output = Self;
3280    #[inline]
3281    fn bitor(self, rhs: Self) -> Self {
3282        Self(self.0 | rhs.0)
3283    }
3284}
3285impl core::ops::BitOrAssign for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3286    #[inline]
3287    fn bitor_assign(&mut self, rhs: Self) {
3288        self.0 |= rhs.0;
3289    }
3290}
3291impl core::ops::BitAnd for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3292    type Output = Self;
3293    #[inline]
3294    fn bitand(self, rhs: Self) -> Self {
3295        Self(self.0 & rhs.0)
3296    }
3297}
3298impl core::ops::BitAndAssign for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3299    #[inline]
3300    fn bitand_assign(&mut self, rhs: Self) {
3301        self.0 &= rhs.0;
3302    }
3303}
3304impl core::ops::BitXor for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3305    type Output = Self;
3306    #[inline]
3307    fn bitxor(self, rhs: Self) -> Self {
3308        Self(self.0 ^ rhs.0)
3309    }
3310}
3311impl core::ops::BitXorAssign for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3312    #[inline]
3313    fn bitxor_assign(&mut self, rhs: Self) {
3314        self.0 ^= rhs.0;
3315    }
3316}
3317impl core::ops::Not for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3318    type Output = Self;
3319    #[inline]
3320    fn not(self) -> Self {
3321        Self(!self.0)
3322    }
3323}
3324impl core::fmt::Debug for ClusterAccelerationStructureIndexFormatFlagBitsNV {
3325    #[allow(unused_mut, unused_variables)]
3326    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3327        let mut first = true;
3328        let mut remaining = self.0;
3329        if remaining & Self::_8BIT.0 != 0 {
3330            if !first {
3331                f.write_str(" | ")?;
3332            }
3333            f.write_str("_8BIT")?;
3334            remaining &= !Self::_8BIT.0;
3335            first = false;
3336        }
3337        if remaining & Self::_16BIT.0 != 0 {
3338            if !first {
3339                f.write_str(" | ")?;
3340            }
3341            f.write_str("_16BIT")?;
3342            remaining &= !Self::_16BIT.0;
3343            first = false;
3344        }
3345        if remaining & Self::_32BIT.0 != 0 {
3346            if !first {
3347                f.write_str(" | ")?;
3348            }
3349            f.write_str("_32BIT")?;
3350            remaining &= !Self::_32BIT.0;
3351            first = false;
3352        }
3353        if remaining != 0u32 {
3354            if !first {
3355                f.write_str(" | ")?;
3356            }
3357            write!(f, "{:#x}", remaining)?;
3358        } else if first {
3359            f.write_str("(empty)")?;
3360        }
3361        Ok(())
3362    }
3363}
3364///[`VkColorComponentFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorComponentFlagBits.html)
3365#[repr(transparent)]
3366#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3367#[doc(alias = "VkColorComponentFlagBits")]
3368pub struct ColorComponentFlagBits(u32);
3369impl ColorComponentFlagBits {
3370    #[inline]
3371    pub const fn empty() -> Self {
3372        Self(0u32)
3373    }
3374    #[inline]
3375    pub const fn from_raw(value: u32) -> Self {
3376        Self(value)
3377    }
3378    #[inline]
3379    pub const fn as_raw(self) -> u32 {
3380        self.0
3381    }
3382    #[inline]
3383    pub const fn is_empty(self) -> bool {
3384        self.0 == 0u32
3385    }
3386    #[inline]
3387    pub const fn contains(self, other: Self) -> bool {
3388        (self.0 & other.0) == other.0
3389    }
3390    ///Bit 0.
3391    pub const R: Self = Self(1u32);
3392    ///Bit 1.
3393    pub const G: Self = Self(2u32);
3394    ///Bit 2.
3395    pub const B: Self = Self(4u32);
3396    ///Bit 3.
3397    pub const A: Self = Self(8u32);
3398}
3399impl core::ops::BitOr for ColorComponentFlagBits {
3400    type Output = Self;
3401    #[inline]
3402    fn bitor(self, rhs: Self) -> Self {
3403        Self(self.0 | rhs.0)
3404    }
3405}
3406impl core::ops::BitOrAssign for ColorComponentFlagBits {
3407    #[inline]
3408    fn bitor_assign(&mut self, rhs: Self) {
3409        self.0 |= rhs.0;
3410    }
3411}
3412impl core::ops::BitAnd for ColorComponentFlagBits {
3413    type Output = Self;
3414    #[inline]
3415    fn bitand(self, rhs: Self) -> Self {
3416        Self(self.0 & rhs.0)
3417    }
3418}
3419impl core::ops::BitAndAssign for ColorComponentFlagBits {
3420    #[inline]
3421    fn bitand_assign(&mut self, rhs: Self) {
3422        self.0 &= rhs.0;
3423    }
3424}
3425impl core::ops::BitXor for ColorComponentFlagBits {
3426    type Output = Self;
3427    #[inline]
3428    fn bitxor(self, rhs: Self) -> Self {
3429        Self(self.0 ^ rhs.0)
3430    }
3431}
3432impl core::ops::BitXorAssign for ColorComponentFlagBits {
3433    #[inline]
3434    fn bitxor_assign(&mut self, rhs: Self) {
3435        self.0 ^= rhs.0;
3436    }
3437}
3438impl core::ops::Not for ColorComponentFlagBits {
3439    type Output = Self;
3440    #[inline]
3441    fn not(self) -> Self {
3442        Self(!self.0)
3443    }
3444}
3445impl core::fmt::Debug for ColorComponentFlagBits {
3446    #[allow(unused_mut, unused_variables)]
3447    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3448        let mut first = true;
3449        let mut remaining = self.0;
3450        if remaining & Self::R.0 != 0 {
3451            if !first {
3452                f.write_str(" | ")?;
3453            }
3454            f.write_str("R")?;
3455            remaining &= !Self::R.0;
3456            first = false;
3457        }
3458        if remaining & Self::G.0 != 0 {
3459            if !first {
3460                f.write_str(" | ")?;
3461            }
3462            f.write_str("G")?;
3463            remaining &= !Self::G.0;
3464            first = false;
3465        }
3466        if remaining & Self::B.0 != 0 {
3467            if !first {
3468                f.write_str(" | ")?;
3469            }
3470            f.write_str("B")?;
3471            remaining &= !Self::B.0;
3472            first = false;
3473        }
3474        if remaining & Self::A.0 != 0 {
3475            if !first {
3476                f.write_str(" | ")?;
3477            }
3478            f.write_str("A")?;
3479            remaining &= !Self::A.0;
3480            first = false;
3481        }
3482        if remaining != 0u32 {
3483            if !first {
3484                f.write_str(" | ")?;
3485            }
3486            write!(f, "{:#x}", remaining)?;
3487        } else if first {
3488            f.write_str("(empty)")?;
3489        }
3490        Ok(())
3491    }
3492}
3493///[`VkCommandBufferResetFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferResetFlagBits.html)
3494#[repr(transparent)]
3495#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3496#[doc(alias = "VkCommandBufferResetFlagBits")]
3497pub struct CommandBufferResetFlagBits(u32);
3498impl CommandBufferResetFlagBits {
3499    #[inline]
3500    pub const fn empty() -> Self {
3501        Self(0u32)
3502    }
3503    #[inline]
3504    pub const fn from_raw(value: u32) -> Self {
3505        Self(value)
3506    }
3507    #[inline]
3508    pub const fn as_raw(self) -> u32 {
3509        self.0
3510    }
3511    #[inline]
3512    pub const fn is_empty(self) -> bool {
3513        self.0 == 0u32
3514    }
3515    #[inline]
3516    pub const fn contains(self, other: Self) -> bool {
3517        (self.0 & other.0) == other.0
3518    }
3519    ///Bit 0.
3520    pub const RELEASE_RESOURCES: Self = Self(1u32);
3521}
3522impl core::ops::BitOr for CommandBufferResetFlagBits {
3523    type Output = Self;
3524    #[inline]
3525    fn bitor(self, rhs: Self) -> Self {
3526        Self(self.0 | rhs.0)
3527    }
3528}
3529impl core::ops::BitOrAssign for CommandBufferResetFlagBits {
3530    #[inline]
3531    fn bitor_assign(&mut self, rhs: Self) {
3532        self.0 |= rhs.0;
3533    }
3534}
3535impl core::ops::BitAnd for CommandBufferResetFlagBits {
3536    type Output = Self;
3537    #[inline]
3538    fn bitand(self, rhs: Self) -> Self {
3539        Self(self.0 & rhs.0)
3540    }
3541}
3542impl core::ops::BitAndAssign for CommandBufferResetFlagBits {
3543    #[inline]
3544    fn bitand_assign(&mut self, rhs: Self) {
3545        self.0 &= rhs.0;
3546    }
3547}
3548impl core::ops::BitXor for CommandBufferResetFlagBits {
3549    type Output = Self;
3550    #[inline]
3551    fn bitxor(self, rhs: Self) -> Self {
3552        Self(self.0 ^ rhs.0)
3553    }
3554}
3555impl core::ops::BitXorAssign for CommandBufferResetFlagBits {
3556    #[inline]
3557    fn bitxor_assign(&mut self, rhs: Self) {
3558        self.0 ^= rhs.0;
3559    }
3560}
3561impl core::ops::Not for CommandBufferResetFlagBits {
3562    type Output = Self;
3563    #[inline]
3564    fn not(self) -> Self {
3565        Self(!self.0)
3566    }
3567}
3568impl core::fmt::Debug for CommandBufferResetFlagBits {
3569    #[allow(unused_mut, unused_variables)]
3570    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3571        let mut first = true;
3572        let mut remaining = self.0;
3573        if remaining & Self::RELEASE_RESOURCES.0 != 0 {
3574            if !first {
3575                f.write_str(" | ")?;
3576            }
3577            f.write_str("RELEASE_RESOURCES")?;
3578            remaining &= !Self::RELEASE_RESOURCES.0;
3579            first = false;
3580        }
3581        if remaining != 0u32 {
3582            if !first {
3583                f.write_str(" | ")?;
3584            }
3585            write!(f, "{:#x}", remaining)?;
3586        } else if first {
3587            f.write_str("(empty)")?;
3588        }
3589        Ok(())
3590    }
3591}
3592///[`VkCommandBufferUsageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferUsageFlagBits.html)
3593#[repr(transparent)]
3594#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3595#[doc(alias = "VkCommandBufferUsageFlagBits")]
3596pub struct CommandBufferUsageFlagBits(u32);
3597impl CommandBufferUsageFlagBits {
3598    #[inline]
3599    pub const fn empty() -> Self {
3600        Self(0u32)
3601    }
3602    #[inline]
3603    pub const fn from_raw(value: u32) -> Self {
3604        Self(value)
3605    }
3606    #[inline]
3607    pub const fn as_raw(self) -> u32 {
3608        self.0
3609    }
3610    #[inline]
3611    pub const fn is_empty(self) -> bool {
3612        self.0 == 0u32
3613    }
3614    #[inline]
3615    pub const fn contains(self, other: Self) -> bool {
3616        (self.0 & other.0) == other.0
3617    }
3618    ///Bit 0.
3619    pub const ONE_TIME_SUBMIT: Self = Self(1u32);
3620    ///Bit 1.
3621    pub const RENDER_PASS_CONTINUE: Self = Self(2u32);
3622    ///Bit 2.
3623    pub const SIMULTANEOUS_USE: Self = Self(4u32);
3624}
3625impl core::ops::BitOr for CommandBufferUsageFlagBits {
3626    type Output = Self;
3627    #[inline]
3628    fn bitor(self, rhs: Self) -> Self {
3629        Self(self.0 | rhs.0)
3630    }
3631}
3632impl core::ops::BitOrAssign for CommandBufferUsageFlagBits {
3633    #[inline]
3634    fn bitor_assign(&mut self, rhs: Self) {
3635        self.0 |= rhs.0;
3636    }
3637}
3638impl core::ops::BitAnd for CommandBufferUsageFlagBits {
3639    type Output = Self;
3640    #[inline]
3641    fn bitand(self, rhs: Self) -> Self {
3642        Self(self.0 & rhs.0)
3643    }
3644}
3645impl core::ops::BitAndAssign for CommandBufferUsageFlagBits {
3646    #[inline]
3647    fn bitand_assign(&mut self, rhs: Self) {
3648        self.0 &= rhs.0;
3649    }
3650}
3651impl core::ops::BitXor for CommandBufferUsageFlagBits {
3652    type Output = Self;
3653    #[inline]
3654    fn bitxor(self, rhs: Self) -> Self {
3655        Self(self.0 ^ rhs.0)
3656    }
3657}
3658impl core::ops::BitXorAssign for CommandBufferUsageFlagBits {
3659    #[inline]
3660    fn bitxor_assign(&mut self, rhs: Self) {
3661        self.0 ^= rhs.0;
3662    }
3663}
3664impl core::ops::Not for CommandBufferUsageFlagBits {
3665    type Output = Self;
3666    #[inline]
3667    fn not(self) -> Self {
3668        Self(!self.0)
3669    }
3670}
3671impl core::fmt::Debug for CommandBufferUsageFlagBits {
3672    #[allow(unused_mut, unused_variables)]
3673    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3674        let mut first = true;
3675        let mut remaining = self.0;
3676        if remaining & Self::ONE_TIME_SUBMIT.0 != 0 {
3677            if !first {
3678                f.write_str(" | ")?;
3679            }
3680            f.write_str("ONE_TIME_SUBMIT")?;
3681            remaining &= !Self::ONE_TIME_SUBMIT.0;
3682            first = false;
3683        }
3684        if remaining & Self::RENDER_PASS_CONTINUE.0 != 0 {
3685            if !first {
3686                f.write_str(" | ")?;
3687            }
3688            f.write_str("RENDER_PASS_CONTINUE")?;
3689            remaining &= !Self::RENDER_PASS_CONTINUE.0;
3690            first = false;
3691        }
3692        if remaining & Self::SIMULTANEOUS_USE.0 != 0 {
3693            if !first {
3694                f.write_str(" | ")?;
3695            }
3696            f.write_str("SIMULTANEOUS_USE")?;
3697            remaining &= !Self::SIMULTANEOUS_USE.0;
3698            first = false;
3699        }
3700        if remaining != 0u32 {
3701            if !first {
3702                f.write_str(" | ")?;
3703            }
3704            write!(f, "{:#x}", remaining)?;
3705        } else if first {
3706            f.write_str("(empty)")?;
3707        }
3708        Ok(())
3709    }
3710}
3711///[`VkCommandPoolCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateFlagBits.html)
3712#[repr(transparent)]
3713#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3714#[doc(alias = "VkCommandPoolCreateFlagBits")]
3715pub struct CommandPoolCreateFlagBits(u32);
3716impl CommandPoolCreateFlagBits {
3717    #[inline]
3718    pub const fn empty() -> Self {
3719        Self(0u32)
3720    }
3721    #[inline]
3722    pub const fn from_raw(value: u32) -> Self {
3723        Self(value)
3724    }
3725    #[inline]
3726    pub const fn as_raw(self) -> u32 {
3727        self.0
3728    }
3729    #[inline]
3730    pub const fn is_empty(self) -> bool {
3731        self.0 == 0u32
3732    }
3733    #[inline]
3734    pub const fn contains(self, other: Self) -> bool {
3735        (self.0 & other.0) == other.0
3736    }
3737    ///Bit 0.
3738    pub const TRANSIENT: Self = Self(1u32);
3739    ///Bit 1.
3740    pub const RESET_COMMAND_BUFFER: Self = Self(2u32);
3741    ///Bit 2.
3742    pub const PROTECTED: Self = Self(4u32);
3743}
3744impl core::ops::BitOr for CommandPoolCreateFlagBits {
3745    type Output = Self;
3746    #[inline]
3747    fn bitor(self, rhs: Self) -> Self {
3748        Self(self.0 | rhs.0)
3749    }
3750}
3751impl core::ops::BitOrAssign for CommandPoolCreateFlagBits {
3752    #[inline]
3753    fn bitor_assign(&mut self, rhs: Self) {
3754        self.0 |= rhs.0;
3755    }
3756}
3757impl core::ops::BitAnd for CommandPoolCreateFlagBits {
3758    type Output = Self;
3759    #[inline]
3760    fn bitand(self, rhs: Self) -> Self {
3761        Self(self.0 & rhs.0)
3762    }
3763}
3764impl core::ops::BitAndAssign for CommandPoolCreateFlagBits {
3765    #[inline]
3766    fn bitand_assign(&mut self, rhs: Self) {
3767        self.0 &= rhs.0;
3768    }
3769}
3770impl core::ops::BitXor for CommandPoolCreateFlagBits {
3771    type Output = Self;
3772    #[inline]
3773    fn bitxor(self, rhs: Self) -> Self {
3774        Self(self.0 ^ rhs.0)
3775    }
3776}
3777impl core::ops::BitXorAssign for CommandPoolCreateFlagBits {
3778    #[inline]
3779    fn bitxor_assign(&mut self, rhs: Self) {
3780        self.0 ^= rhs.0;
3781    }
3782}
3783impl core::ops::Not for CommandPoolCreateFlagBits {
3784    type Output = Self;
3785    #[inline]
3786    fn not(self) -> Self {
3787        Self(!self.0)
3788    }
3789}
3790impl core::fmt::Debug for CommandPoolCreateFlagBits {
3791    #[allow(unused_mut, unused_variables)]
3792    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3793        let mut first = true;
3794        let mut remaining = self.0;
3795        if remaining & Self::TRANSIENT.0 != 0 {
3796            if !first {
3797                f.write_str(" | ")?;
3798            }
3799            f.write_str("TRANSIENT")?;
3800            remaining &= !Self::TRANSIENT.0;
3801            first = false;
3802        }
3803        if remaining & Self::RESET_COMMAND_BUFFER.0 != 0 {
3804            if !first {
3805                f.write_str(" | ")?;
3806            }
3807            f.write_str("RESET_COMMAND_BUFFER")?;
3808            remaining &= !Self::RESET_COMMAND_BUFFER.0;
3809            first = false;
3810        }
3811        if remaining & Self::PROTECTED.0 != 0 {
3812            if !first {
3813                f.write_str(" | ")?;
3814            }
3815            f.write_str("PROTECTED")?;
3816            remaining &= !Self::PROTECTED.0;
3817            first = false;
3818        }
3819        if remaining != 0u32 {
3820            if !first {
3821                f.write_str(" | ")?;
3822            }
3823            write!(f, "{:#x}", remaining)?;
3824        } else if first {
3825            f.write_str("(empty)")?;
3826        }
3827        Ok(())
3828    }
3829}
3830///[`VkCommandPoolResetFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolResetFlagBits.html)
3831#[repr(transparent)]
3832#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3833#[doc(alias = "VkCommandPoolResetFlagBits")]
3834pub struct CommandPoolResetFlagBits(u32);
3835impl CommandPoolResetFlagBits {
3836    #[inline]
3837    pub const fn empty() -> Self {
3838        Self(0u32)
3839    }
3840    #[inline]
3841    pub const fn from_raw(value: u32) -> Self {
3842        Self(value)
3843    }
3844    #[inline]
3845    pub const fn as_raw(self) -> u32 {
3846        self.0
3847    }
3848    #[inline]
3849    pub const fn is_empty(self) -> bool {
3850        self.0 == 0u32
3851    }
3852    #[inline]
3853    pub const fn contains(self, other: Self) -> bool {
3854        (self.0 & other.0) == other.0
3855    }
3856    ///Bit 0.
3857    pub const RELEASE_RESOURCES: Self = Self(1u32);
3858}
3859impl core::ops::BitOr for CommandPoolResetFlagBits {
3860    type Output = Self;
3861    #[inline]
3862    fn bitor(self, rhs: Self) -> Self {
3863        Self(self.0 | rhs.0)
3864    }
3865}
3866impl core::ops::BitOrAssign for CommandPoolResetFlagBits {
3867    #[inline]
3868    fn bitor_assign(&mut self, rhs: Self) {
3869        self.0 |= rhs.0;
3870    }
3871}
3872impl core::ops::BitAnd for CommandPoolResetFlagBits {
3873    type Output = Self;
3874    #[inline]
3875    fn bitand(self, rhs: Self) -> Self {
3876        Self(self.0 & rhs.0)
3877    }
3878}
3879impl core::ops::BitAndAssign for CommandPoolResetFlagBits {
3880    #[inline]
3881    fn bitand_assign(&mut self, rhs: Self) {
3882        self.0 &= rhs.0;
3883    }
3884}
3885impl core::ops::BitXor for CommandPoolResetFlagBits {
3886    type Output = Self;
3887    #[inline]
3888    fn bitxor(self, rhs: Self) -> Self {
3889        Self(self.0 ^ rhs.0)
3890    }
3891}
3892impl core::ops::BitXorAssign for CommandPoolResetFlagBits {
3893    #[inline]
3894    fn bitxor_assign(&mut self, rhs: Self) {
3895        self.0 ^= rhs.0;
3896    }
3897}
3898impl core::ops::Not for CommandPoolResetFlagBits {
3899    type Output = Self;
3900    #[inline]
3901    fn not(self) -> Self {
3902        Self(!self.0)
3903    }
3904}
3905impl core::fmt::Debug for CommandPoolResetFlagBits {
3906    #[allow(unused_mut, unused_variables)]
3907    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3908        let mut first = true;
3909        let mut remaining = self.0;
3910        if remaining & Self::RELEASE_RESOURCES.0 != 0 {
3911            if !first {
3912                f.write_str(" | ")?;
3913            }
3914            f.write_str("RELEASE_RESOURCES")?;
3915            remaining &= !Self::RELEASE_RESOURCES.0;
3916            first = false;
3917        }
3918        if remaining != 0u32 {
3919            if !first {
3920                f.write_str(" | ")?;
3921            }
3922            write!(f, "{:#x}", remaining)?;
3923        } else if first {
3924            f.write_str("(empty)")?;
3925        }
3926        Ok(())
3927    }
3928}
3929///[`VkCompositeAlphaFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompositeAlphaFlagBitsKHR.html)
3930#[repr(transparent)]
3931#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
3932#[doc(alias = "VkCompositeAlphaFlagBitsKHR")]
3933pub struct CompositeAlphaFlagBitsKHR(u32);
3934impl CompositeAlphaFlagBitsKHR {
3935    #[inline]
3936    pub const fn empty() -> Self {
3937        Self(0u32)
3938    }
3939    #[inline]
3940    pub const fn from_raw(value: u32) -> Self {
3941        Self(value)
3942    }
3943    #[inline]
3944    pub const fn as_raw(self) -> u32 {
3945        self.0
3946    }
3947    #[inline]
3948    pub const fn is_empty(self) -> bool {
3949        self.0 == 0u32
3950    }
3951    #[inline]
3952    pub const fn contains(self, other: Self) -> bool {
3953        (self.0 & other.0) == other.0
3954    }
3955    ///Bit 0.
3956    pub const OPAQUE: Self = Self(1u32);
3957    ///Bit 1.
3958    pub const PRE_MULTIPLIED: Self = Self(2u32);
3959    ///Bit 2.
3960    pub const POST_MULTIPLIED: Self = Self(4u32);
3961    ///Bit 3.
3962    pub const INHERIT: Self = Self(8u32);
3963}
3964impl core::ops::BitOr for CompositeAlphaFlagBitsKHR {
3965    type Output = Self;
3966    #[inline]
3967    fn bitor(self, rhs: Self) -> Self {
3968        Self(self.0 | rhs.0)
3969    }
3970}
3971impl core::ops::BitOrAssign for CompositeAlphaFlagBitsKHR {
3972    #[inline]
3973    fn bitor_assign(&mut self, rhs: Self) {
3974        self.0 |= rhs.0;
3975    }
3976}
3977impl core::ops::BitAnd for CompositeAlphaFlagBitsKHR {
3978    type Output = Self;
3979    #[inline]
3980    fn bitand(self, rhs: Self) -> Self {
3981        Self(self.0 & rhs.0)
3982    }
3983}
3984impl core::ops::BitAndAssign for CompositeAlphaFlagBitsKHR {
3985    #[inline]
3986    fn bitand_assign(&mut self, rhs: Self) {
3987        self.0 &= rhs.0;
3988    }
3989}
3990impl core::ops::BitXor for CompositeAlphaFlagBitsKHR {
3991    type Output = Self;
3992    #[inline]
3993    fn bitxor(self, rhs: Self) -> Self {
3994        Self(self.0 ^ rhs.0)
3995    }
3996}
3997impl core::ops::BitXorAssign for CompositeAlphaFlagBitsKHR {
3998    #[inline]
3999    fn bitxor_assign(&mut self, rhs: Self) {
4000        self.0 ^= rhs.0;
4001    }
4002}
4003impl core::ops::Not for CompositeAlphaFlagBitsKHR {
4004    type Output = Self;
4005    #[inline]
4006    fn not(self) -> Self {
4007        Self(!self.0)
4008    }
4009}
4010impl core::fmt::Debug for CompositeAlphaFlagBitsKHR {
4011    #[allow(unused_mut, unused_variables)]
4012    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4013        let mut first = true;
4014        let mut remaining = self.0;
4015        if remaining & Self::OPAQUE.0 != 0 {
4016            if !first {
4017                f.write_str(" | ")?;
4018            }
4019            f.write_str("OPAQUE")?;
4020            remaining &= !Self::OPAQUE.0;
4021            first = false;
4022        }
4023        if remaining & Self::PRE_MULTIPLIED.0 != 0 {
4024            if !first {
4025                f.write_str(" | ")?;
4026            }
4027            f.write_str("PRE_MULTIPLIED")?;
4028            remaining &= !Self::PRE_MULTIPLIED.0;
4029            first = false;
4030        }
4031        if remaining & Self::POST_MULTIPLIED.0 != 0 {
4032            if !first {
4033                f.write_str(" | ")?;
4034            }
4035            f.write_str("POST_MULTIPLIED")?;
4036            remaining &= !Self::POST_MULTIPLIED.0;
4037            first = false;
4038        }
4039        if remaining & Self::INHERIT.0 != 0 {
4040            if !first {
4041                f.write_str(" | ")?;
4042            }
4043            f.write_str("INHERIT")?;
4044            remaining &= !Self::INHERIT.0;
4045            first = false;
4046        }
4047        if remaining != 0u32 {
4048            if !first {
4049                f.write_str(" | ")?;
4050            }
4051            write!(f, "{:#x}", remaining)?;
4052        } else if first {
4053            f.write_str("(empty)")?;
4054        }
4055        Ok(())
4056    }
4057}
4058///[`VkConditionalRenderingFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingFlagBitsEXT.html)
4059#[repr(transparent)]
4060#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
4061#[doc(alias = "VkConditionalRenderingFlagBitsEXT")]
4062pub struct ConditionalRenderingFlagBitsEXT(u32);
4063impl ConditionalRenderingFlagBitsEXT {
4064    #[inline]
4065    pub const fn empty() -> Self {
4066        Self(0u32)
4067    }
4068    #[inline]
4069    pub const fn from_raw(value: u32) -> Self {
4070        Self(value)
4071    }
4072    #[inline]
4073    pub const fn as_raw(self) -> u32 {
4074        self.0
4075    }
4076    #[inline]
4077    pub const fn is_empty(self) -> bool {
4078        self.0 == 0u32
4079    }
4080    #[inline]
4081    pub const fn contains(self, other: Self) -> bool {
4082        (self.0 & other.0) == other.0
4083    }
4084    ///Bit 0.
4085    pub const INVERTED: Self = Self(1u32);
4086}
4087impl core::ops::BitOr for ConditionalRenderingFlagBitsEXT {
4088    type Output = Self;
4089    #[inline]
4090    fn bitor(self, rhs: Self) -> Self {
4091        Self(self.0 | rhs.0)
4092    }
4093}
4094impl core::ops::BitOrAssign for ConditionalRenderingFlagBitsEXT {
4095    #[inline]
4096    fn bitor_assign(&mut self, rhs: Self) {
4097        self.0 |= rhs.0;
4098    }
4099}
4100impl core::ops::BitAnd for ConditionalRenderingFlagBitsEXT {
4101    type Output = Self;
4102    #[inline]
4103    fn bitand(self, rhs: Self) -> Self {
4104        Self(self.0 & rhs.0)
4105    }
4106}
4107impl core::ops::BitAndAssign for ConditionalRenderingFlagBitsEXT {
4108    #[inline]
4109    fn bitand_assign(&mut self, rhs: Self) {
4110        self.0 &= rhs.0;
4111    }
4112}
4113impl core::ops::BitXor for ConditionalRenderingFlagBitsEXT {
4114    type Output = Self;
4115    #[inline]
4116    fn bitxor(self, rhs: Self) -> Self {
4117        Self(self.0 ^ rhs.0)
4118    }
4119}
4120impl core::ops::BitXorAssign for ConditionalRenderingFlagBitsEXT {
4121    #[inline]
4122    fn bitxor_assign(&mut self, rhs: Self) {
4123        self.0 ^= rhs.0;
4124    }
4125}
4126impl core::ops::Not for ConditionalRenderingFlagBitsEXT {
4127    type Output = Self;
4128    #[inline]
4129    fn not(self) -> Self {
4130        Self(!self.0)
4131    }
4132}
4133impl core::fmt::Debug for ConditionalRenderingFlagBitsEXT {
4134    #[allow(unused_mut, unused_variables)]
4135    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4136        let mut first = true;
4137        let mut remaining = self.0;
4138        if remaining & Self::INVERTED.0 != 0 {
4139            if !first {
4140                f.write_str(" | ")?;
4141            }
4142            f.write_str("INVERTED")?;
4143            remaining &= !Self::INVERTED.0;
4144            first = false;
4145        }
4146        if remaining != 0u32 {
4147            if !first {
4148                f.write_str(" | ")?;
4149            }
4150            write!(f, "{:#x}", remaining)?;
4151        } else if first {
4152            f.write_str("(empty)")?;
4153        }
4154        Ok(())
4155    }
4156}
4157///[`VkCullModeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCullModeFlagBits.html)
4158#[repr(transparent)]
4159#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
4160#[doc(alias = "VkCullModeFlagBits")]
4161pub struct CullModeFlagBits(u32);
4162impl CullModeFlagBits {
4163    #[inline]
4164    pub const fn empty() -> Self {
4165        Self(0u32)
4166    }
4167    #[inline]
4168    pub const fn from_raw(value: u32) -> Self {
4169        Self(value)
4170    }
4171    #[inline]
4172    pub const fn as_raw(self) -> u32 {
4173        self.0
4174    }
4175    #[inline]
4176    pub const fn is_empty(self) -> bool {
4177        self.0 == 0u32
4178    }
4179    #[inline]
4180    pub const fn contains(self, other: Self) -> bool {
4181        (self.0 & other.0) == other.0
4182    }
4183    pub const NONE: Self = Self(0u32);
4184    ///Bit 0.
4185    pub const FRONT: Self = Self(1u32);
4186    ///Bit 1.
4187    pub const BACK: Self = Self(2u32);
4188    pub const FRONT_AND_BACK: Self = Self(3u32);
4189}
4190impl core::ops::BitOr for CullModeFlagBits {
4191    type Output = Self;
4192    #[inline]
4193    fn bitor(self, rhs: Self) -> Self {
4194        Self(self.0 | rhs.0)
4195    }
4196}
4197impl core::ops::BitOrAssign for CullModeFlagBits {
4198    #[inline]
4199    fn bitor_assign(&mut self, rhs: Self) {
4200        self.0 |= rhs.0;
4201    }
4202}
4203impl core::ops::BitAnd for CullModeFlagBits {
4204    type Output = Self;
4205    #[inline]
4206    fn bitand(self, rhs: Self) -> Self {
4207        Self(self.0 & rhs.0)
4208    }
4209}
4210impl core::ops::BitAndAssign for CullModeFlagBits {
4211    #[inline]
4212    fn bitand_assign(&mut self, rhs: Self) {
4213        self.0 &= rhs.0;
4214    }
4215}
4216impl core::ops::BitXor for CullModeFlagBits {
4217    type Output = Self;
4218    #[inline]
4219    fn bitxor(self, rhs: Self) -> Self {
4220        Self(self.0 ^ rhs.0)
4221    }
4222}
4223impl core::ops::BitXorAssign for CullModeFlagBits {
4224    #[inline]
4225    fn bitxor_assign(&mut self, rhs: Self) {
4226        self.0 ^= rhs.0;
4227    }
4228}
4229impl core::ops::Not for CullModeFlagBits {
4230    type Output = Self;
4231    #[inline]
4232    fn not(self) -> Self {
4233        Self(!self.0)
4234    }
4235}
4236impl core::fmt::Debug for CullModeFlagBits {
4237    #[allow(unused_mut, unused_variables)]
4238    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4239        let mut first = true;
4240        let mut remaining = self.0;
4241        if remaining & Self::FRONT.0 != 0 {
4242            if !first {
4243                f.write_str(" | ")?;
4244            }
4245            f.write_str("FRONT")?;
4246            remaining &= !Self::FRONT.0;
4247            first = false;
4248        }
4249        if remaining & Self::BACK.0 != 0 {
4250            if !first {
4251                f.write_str(" | ")?;
4252            }
4253            f.write_str("BACK")?;
4254            remaining &= !Self::BACK.0;
4255            first = false;
4256        }
4257        if remaining != 0u32 {
4258            if !first {
4259                f.write_str(" | ")?;
4260            }
4261            write!(f, "{:#x}", remaining)?;
4262        } else if first {
4263            f.write_str("(empty)")?;
4264        }
4265        Ok(())
4266    }
4267}
4268///[`VkDataGraphPipelineDispatchFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineDispatchFlagBitsARM.html)
4269#[repr(transparent)]
4270#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
4271#[doc(alias = "VkDataGraphPipelineDispatchFlagBitsARM")]
4272pub struct DataGraphPipelineDispatchFlagBitsARM(u64);
4273impl DataGraphPipelineDispatchFlagBitsARM {
4274    #[inline]
4275    pub const fn empty() -> Self {
4276        Self(0u64)
4277    }
4278    #[inline]
4279    pub const fn from_raw(value: u64) -> Self {
4280        Self(value)
4281    }
4282    #[inline]
4283    pub const fn as_raw(self) -> u64 {
4284        self.0
4285    }
4286    #[inline]
4287    pub const fn is_empty(self) -> bool {
4288        self.0 == 0u64
4289    }
4290    #[inline]
4291    pub const fn contains(self, other: Self) -> bool {
4292        (self.0 & other.0) == other.0
4293    }
4294}
4295impl core::ops::BitOr for DataGraphPipelineDispatchFlagBitsARM {
4296    type Output = Self;
4297    #[inline]
4298    fn bitor(self, rhs: Self) -> Self {
4299        Self(self.0 | rhs.0)
4300    }
4301}
4302impl core::ops::BitOrAssign for DataGraphPipelineDispatchFlagBitsARM {
4303    #[inline]
4304    fn bitor_assign(&mut self, rhs: Self) {
4305        self.0 |= rhs.0;
4306    }
4307}
4308impl core::ops::BitAnd for DataGraphPipelineDispatchFlagBitsARM {
4309    type Output = Self;
4310    #[inline]
4311    fn bitand(self, rhs: Self) -> Self {
4312        Self(self.0 & rhs.0)
4313    }
4314}
4315impl core::ops::BitAndAssign for DataGraphPipelineDispatchFlagBitsARM {
4316    #[inline]
4317    fn bitand_assign(&mut self, rhs: Self) {
4318        self.0 &= rhs.0;
4319    }
4320}
4321impl core::ops::BitXor for DataGraphPipelineDispatchFlagBitsARM {
4322    type Output = Self;
4323    #[inline]
4324    fn bitxor(self, rhs: Self) -> Self {
4325        Self(self.0 ^ rhs.0)
4326    }
4327}
4328impl core::ops::BitXorAssign for DataGraphPipelineDispatchFlagBitsARM {
4329    #[inline]
4330    fn bitxor_assign(&mut self, rhs: Self) {
4331        self.0 ^= rhs.0;
4332    }
4333}
4334impl core::ops::Not for DataGraphPipelineDispatchFlagBitsARM {
4335    type Output = Self;
4336    #[inline]
4337    fn not(self) -> Self {
4338        Self(!self.0)
4339    }
4340}
4341impl core::fmt::Debug for DataGraphPipelineDispatchFlagBitsARM {
4342    #[allow(unused_mut, unused_variables)]
4343    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4344        let mut first = true;
4345        let mut remaining = self.0;
4346        if remaining != 0u64 {
4347            if !first {
4348                f.write_str(" | ")?;
4349            }
4350            write!(f, "{:#x}", remaining)?;
4351        } else if first {
4352            f.write_str("(empty)")?;
4353        }
4354        Ok(())
4355    }
4356}
4357///[`VkDataGraphPipelineSessionCreateFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateFlagBitsARM.html)
4358#[repr(transparent)]
4359#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
4360#[doc(alias = "VkDataGraphPipelineSessionCreateFlagBitsARM")]
4361pub struct DataGraphPipelineSessionCreateFlagBitsARM(u64);
4362impl DataGraphPipelineSessionCreateFlagBitsARM {
4363    #[inline]
4364    pub const fn empty() -> Self {
4365        Self(0u64)
4366    }
4367    #[inline]
4368    pub const fn from_raw(value: u64) -> Self {
4369        Self(value)
4370    }
4371    #[inline]
4372    pub const fn as_raw(self) -> u64 {
4373        self.0
4374    }
4375    #[inline]
4376    pub const fn is_empty(self) -> bool {
4377        self.0 == 0u64
4378    }
4379    #[inline]
4380    pub const fn contains(self, other: Self) -> bool {
4381        (self.0 & other.0) == other.0
4382    }
4383    ///Bit 0.
4384    pub const PROTECTED_BIT: Self = Self(1u64);
4385}
4386impl core::ops::BitOr for DataGraphPipelineSessionCreateFlagBitsARM {
4387    type Output = Self;
4388    #[inline]
4389    fn bitor(self, rhs: Self) -> Self {
4390        Self(self.0 | rhs.0)
4391    }
4392}
4393impl core::ops::BitOrAssign for DataGraphPipelineSessionCreateFlagBitsARM {
4394    #[inline]
4395    fn bitor_assign(&mut self, rhs: Self) {
4396        self.0 |= rhs.0;
4397    }
4398}
4399impl core::ops::BitAnd for DataGraphPipelineSessionCreateFlagBitsARM {
4400    type Output = Self;
4401    #[inline]
4402    fn bitand(self, rhs: Self) -> Self {
4403        Self(self.0 & rhs.0)
4404    }
4405}
4406impl core::ops::BitAndAssign for DataGraphPipelineSessionCreateFlagBitsARM {
4407    #[inline]
4408    fn bitand_assign(&mut self, rhs: Self) {
4409        self.0 &= rhs.0;
4410    }
4411}
4412impl core::ops::BitXor for DataGraphPipelineSessionCreateFlagBitsARM {
4413    type Output = Self;
4414    #[inline]
4415    fn bitxor(self, rhs: Self) -> Self {
4416        Self(self.0 ^ rhs.0)
4417    }
4418}
4419impl core::ops::BitXorAssign for DataGraphPipelineSessionCreateFlagBitsARM {
4420    #[inline]
4421    fn bitxor_assign(&mut self, rhs: Self) {
4422        self.0 ^= rhs.0;
4423    }
4424}
4425impl core::ops::Not for DataGraphPipelineSessionCreateFlagBitsARM {
4426    type Output = Self;
4427    #[inline]
4428    fn not(self) -> Self {
4429        Self(!self.0)
4430    }
4431}
4432impl core::fmt::Debug for DataGraphPipelineSessionCreateFlagBitsARM {
4433    #[allow(unused_mut, unused_variables)]
4434    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4435        let mut first = true;
4436        let mut remaining = self.0;
4437        if remaining & Self::PROTECTED_BIT.0 != 0 {
4438            if !first {
4439                f.write_str(" | ")?;
4440            }
4441            f.write_str("PROTECTED_BIT")?;
4442            remaining &= !Self::PROTECTED_BIT.0;
4443            first = false;
4444        }
4445        if remaining != 0u64 {
4446            if !first {
4447                f.write_str(" | ")?;
4448            }
4449            write!(f, "{:#x}", remaining)?;
4450        } else if first {
4451            f.write_str("(empty)")?;
4452        }
4453        Ok(())
4454    }
4455}
4456///[`VkDebugReportFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportFlagBitsEXT.html)
4457#[repr(transparent)]
4458#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
4459#[doc(alias = "VkDebugReportFlagBitsEXT")]
4460pub struct DebugReportFlagBitsEXT(u32);
4461impl DebugReportFlagBitsEXT {
4462    #[inline]
4463    pub const fn empty() -> Self {
4464        Self(0u32)
4465    }
4466    #[inline]
4467    pub const fn from_raw(value: u32) -> Self {
4468        Self(value)
4469    }
4470    #[inline]
4471    pub const fn as_raw(self) -> u32 {
4472        self.0
4473    }
4474    #[inline]
4475    pub const fn is_empty(self) -> bool {
4476        self.0 == 0u32
4477    }
4478    #[inline]
4479    pub const fn contains(self, other: Self) -> bool {
4480        (self.0 & other.0) == other.0
4481    }
4482    ///Bit 0.
4483    pub const INFORMATION: Self = Self(1u32);
4484    ///Bit 1.
4485    pub const WARNING: Self = Self(2u32);
4486    ///Bit 2.
4487    pub const PERFORMANCE_WARNING: Self = Self(4u32);
4488    ///Bit 3.
4489    pub const ERROR: Self = Self(8u32);
4490    ///Bit 4.
4491    pub const DEBUG: Self = Self(16u32);
4492}
4493impl core::ops::BitOr for DebugReportFlagBitsEXT {
4494    type Output = Self;
4495    #[inline]
4496    fn bitor(self, rhs: Self) -> Self {
4497        Self(self.0 | rhs.0)
4498    }
4499}
4500impl core::ops::BitOrAssign for DebugReportFlagBitsEXT {
4501    #[inline]
4502    fn bitor_assign(&mut self, rhs: Self) {
4503        self.0 |= rhs.0;
4504    }
4505}
4506impl core::ops::BitAnd for DebugReportFlagBitsEXT {
4507    type Output = Self;
4508    #[inline]
4509    fn bitand(self, rhs: Self) -> Self {
4510        Self(self.0 & rhs.0)
4511    }
4512}
4513impl core::ops::BitAndAssign for DebugReportFlagBitsEXT {
4514    #[inline]
4515    fn bitand_assign(&mut self, rhs: Self) {
4516        self.0 &= rhs.0;
4517    }
4518}
4519impl core::ops::BitXor for DebugReportFlagBitsEXT {
4520    type Output = Self;
4521    #[inline]
4522    fn bitxor(self, rhs: Self) -> Self {
4523        Self(self.0 ^ rhs.0)
4524    }
4525}
4526impl core::ops::BitXorAssign for DebugReportFlagBitsEXT {
4527    #[inline]
4528    fn bitxor_assign(&mut self, rhs: Self) {
4529        self.0 ^= rhs.0;
4530    }
4531}
4532impl core::ops::Not for DebugReportFlagBitsEXT {
4533    type Output = Self;
4534    #[inline]
4535    fn not(self) -> Self {
4536        Self(!self.0)
4537    }
4538}
4539impl core::fmt::Debug for DebugReportFlagBitsEXT {
4540    #[allow(unused_mut, unused_variables)]
4541    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4542        let mut first = true;
4543        let mut remaining = self.0;
4544        if remaining & Self::INFORMATION.0 != 0 {
4545            if !first {
4546                f.write_str(" | ")?;
4547            }
4548            f.write_str("INFORMATION")?;
4549            remaining &= !Self::INFORMATION.0;
4550            first = false;
4551        }
4552        if remaining & Self::WARNING.0 != 0 {
4553            if !first {
4554                f.write_str(" | ")?;
4555            }
4556            f.write_str("WARNING")?;
4557            remaining &= !Self::WARNING.0;
4558            first = false;
4559        }
4560        if remaining & Self::PERFORMANCE_WARNING.0 != 0 {
4561            if !first {
4562                f.write_str(" | ")?;
4563            }
4564            f.write_str("PERFORMANCE_WARNING")?;
4565            remaining &= !Self::PERFORMANCE_WARNING.0;
4566            first = false;
4567        }
4568        if remaining & Self::ERROR.0 != 0 {
4569            if !first {
4570                f.write_str(" | ")?;
4571            }
4572            f.write_str("ERROR")?;
4573            remaining &= !Self::ERROR.0;
4574            first = false;
4575        }
4576        if remaining & Self::DEBUG.0 != 0 {
4577            if !first {
4578                f.write_str(" | ")?;
4579            }
4580            f.write_str("DEBUG")?;
4581            remaining &= !Self::DEBUG.0;
4582            first = false;
4583        }
4584        if remaining != 0u32 {
4585            if !first {
4586                f.write_str(" | ")?;
4587            }
4588            write!(f, "{:#x}", remaining)?;
4589        } else if first {
4590            f.write_str("(empty)")?;
4591        }
4592        Ok(())
4593    }
4594}
4595///[`VkDebugUtilsMessageSeverityFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html)
4596#[repr(transparent)]
4597#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
4598#[doc(alias = "VkDebugUtilsMessageSeverityFlagBitsEXT")]
4599pub struct DebugUtilsMessageSeverityFlagBitsEXT(u32);
4600impl DebugUtilsMessageSeverityFlagBitsEXT {
4601    #[inline]
4602    pub const fn empty() -> Self {
4603        Self(0u32)
4604    }
4605    #[inline]
4606    pub const fn from_raw(value: u32) -> Self {
4607        Self(value)
4608    }
4609    #[inline]
4610    pub const fn as_raw(self) -> u32 {
4611        self.0
4612    }
4613    #[inline]
4614    pub const fn is_empty(self) -> bool {
4615        self.0 == 0u32
4616    }
4617    #[inline]
4618    pub const fn contains(self, other: Self) -> bool {
4619        (self.0 & other.0) == other.0
4620    }
4621    ///Bit 0.
4622    pub const VERBOSE: Self = Self(1u32);
4623    ///Bit 4.
4624    pub const INFO: Self = Self(16u32);
4625    ///Bit 8.
4626    pub const WARNING: Self = Self(256u32);
4627    ///Bit 12.
4628    pub const ERROR: Self = Self(4096u32);
4629}
4630impl core::ops::BitOr for DebugUtilsMessageSeverityFlagBitsEXT {
4631    type Output = Self;
4632    #[inline]
4633    fn bitor(self, rhs: Self) -> Self {
4634        Self(self.0 | rhs.0)
4635    }
4636}
4637impl core::ops::BitOrAssign for DebugUtilsMessageSeverityFlagBitsEXT {
4638    #[inline]
4639    fn bitor_assign(&mut self, rhs: Self) {
4640        self.0 |= rhs.0;
4641    }
4642}
4643impl core::ops::BitAnd for DebugUtilsMessageSeverityFlagBitsEXT {
4644    type Output = Self;
4645    #[inline]
4646    fn bitand(self, rhs: Self) -> Self {
4647        Self(self.0 & rhs.0)
4648    }
4649}
4650impl core::ops::BitAndAssign for DebugUtilsMessageSeverityFlagBitsEXT {
4651    #[inline]
4652    fn bitand_assign(&mut self, rhs: Self) {
4653        self.0 &= rhs.0;
4654    }
4655}
4656impl core::ops::BitXor for DebugUtilsMessageSeverityFlagBitsEXT {
4657    type Output = Self;
4658    #[inline]
4659    fn bitxor(self, rhs: Self) -> Self {
4660        Self(self.0 ^ rhs.0)
4661    }
4662}
4663impl core::ops::BitXorAssign for DebugUtilsMessageSeverityFlagBitsEXT {
4664    #[inline]
4665    fn bitxor_assign(&mut self, rhs: Self) {
4666        self.0 ^= rhs.0;
4667    }
4668}
4669impl core::ops::Not for DebugUtilsMessageSeverityFlagBitsEXT {
4670    type Output = Self;
4671    #[inline]
4672    fn not(self) -> Self {
4673        Self(!self.0)
4674    }
4675}
4676impl core::fmt::Debug for DebugUtilsMessageSeverityFlagBitsEXT {
4677    #[allow(unused_mut, unused_variables)]
4678    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4679        let mut first = true;
4680        let mut remaining = self.0;
4681        if remaining & Self::VERBOSE.0 != 0 {
4682            if !first {
4683                f.write_str(" | ")?;
4684            }
4685            f.write_str("VERBOSE")?;
4686            remaining &= !Self::VERBOSE.0;
4687            first = false;
4688        }
4689        if remaining & Self::INFO.0 != 0 {
4690            if !first {
4691                f.write_str(" | ")?;
4692            }
4693            f.write_str("INFO")?;
4694            remaining &= !Self::INFO.0;
4695            first = false;
4696        }
4697        if remaining & Self::WARNING.0 != 0 {
4698            if !first {
4699                f.write_str(" | ")?;
4700            }
4701            f.write_str("WARNING")?;
4702            remaining &= !Self::WARNING.0;
4703            first = false;
4704        }
4705        if remaining & Self::ERROR.0 != 0 {
4706            if !first {
4707                f.write_str(" | ")?;
4708            }
4709            f.write_str("ERROR")?;
4710            remaining &= !Self::ERROR.0;
4711            first = false;
4712        }
4713        if remaining != 0u32 {
4714            if !first {
4715                f.write_str(" | ")?;
4716            }
4717            write!(f, "{:#x}", remaining)?;
4718        } else if first {
4719            f.write_str("(empty)")?;
4720        }
4721        Ok(())
4722    }
4723}
4724///[`VkDebugUtilsMessageTypeFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html)
4725#[repr(transparent)]
4726#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
4727#[doc(alias = "VkDebugUtilsMessageTypeFlagBitsEXT")]
4728pub struct DebugUtilsMessageTypeFlagBitsEXT(u32);
4729impl DebugUtilsMessageTypeFlagBitsEXT {
4730    #[inline]
4731    pub const fn empty() -> Self {
4732        Self(0u32)
4733    }
4734    #[inline]
4735    pub const fn from_raw(value: u32) -> Self {
4736        Self(value)
4737    }
4738    #[inline]
4739    pub const fn as_raw(self) -> u32 {
4740        self.0
4741    }
4742    #[inline]
4743    pub const fn is_empty(self) -> bool {
4744        self.0 == 0u32
4745    }
4746    #[inline]
4747    pub const fn contains(self, other: Self) -> bool {
4748        (self.0 & other.0) == other.0
4749    }
4750    ///Bit 0.
4751    pub const GENERAL: Self = Self(1u32);
4752    ///Bit 1.
4753    pub const VALIDATION: Self = Self(2u32);
4754    ///Bit 2.
4755    pub const PERFORMANCE: Self = Self(4u32);
4756    ///Bit 3.
4757    pub const DEVICE_ADDRESS_BINDING: Self = Self(8u32);
4758}
4759impl core::ops::BitOr for DebugUtilsMessageTypeFlagBitsEXT {
4760    type Output = Self;
4761    #[inline]
4762    fn bitor(self, rhs: Self) -> Self {
4763        Self(self.0 | rhs.0)
4764    }
4765}
4766impl core::ops::BitOrAssign for DebugUtilsMessageTypeFlagBitsEXT {
4767    #[inline]
4768    fn bitor_assign(&mut self, rhs: Self) {
4769        self.0 |= rhs.0;
4770    }
4771}
4772impl core::ops::BitAnd for DebugUtilsMessageTypeFlagBitsEXT {
4773    type Output = Self;
4774    #[inline]
4775    fn bitand(self, rhs: Self) -> Self {
4776        Self(self.0 & rhs.0)
4777    }
4778}
4779impl core::ops::BitAndAssign for DebugUtilsMessageTypeFlagBitsEXT {
4780    #[inline]
4781    fn bitand_assign(&mut self, rhs: Self) {
4782        self.0 &= rhs.0;
4783    }
4784}
4785impl core::ops::BitXor for DebugUtilsMessageTypeFlagBitsEXT {
4786    type Output = Self;
4787    #[inline]
4788    fn bitxor(self, rhs: Self) -> Self {
4789        Self(self.0 ^ rhs.0)
4790    }
4791}
4792impl core::ops::BitXorAssign for DebugUtilsMessageTypeFlagBitsEXT {
4793    #[inline]
4794    fn bitxor_assign(&mut self, rhs: Self) {
4795        self.0 ^= rhs.0;
4796    }
4797}
4798impl core::ops::Not for DebugUtilsMessageTypeFlagBitsEXT {
4799    type Output = Self;
4800    #[inline]
4801    fn not(self) -> Self {
4802        Self(!self.0)
4803    }
4804}
4805impl core::fmt::Debug for DebugUtilsMessageTypeFlagBitsEXT {
4806    #[allow(unused_mut, unused_variables)]
4807    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4808        let mut first = true;
4809        let mut remaining = self.0;
4810        if remaining & Self::GENERAL.0 != 0 {
4811            if !first {
4812                f.write_str(" | ")?;
4813            }
4814            f.write_str("GENERAL")?;
4815            remaining &= !Self::GENERAL.0;
4816            first = false;
4817        }
4818        if remaining & Self::VALIDATION.0 != 0 {
4819            if !first {
4820                f.write_str(" | ")?;
4821            }
4822            f.write_str("VALIDATION")?;
4823            remaining &= !Self::VALIDATION.0;
4824            first = false;
4825        }
4826        if remaining & Self::PERFORMANCE.0 != 0 {
4827            if !first {
4828                f.write_str(" | ")?;
4829            }
4830            f.write_str("PERFORMANCE")?;
4831            remaining &= !Self::PERFORMANCE.0;
4832            first = false;
4833        }
4834        if remaining & Self::DEVICE_ADDRESS_BINDING.0 != 0 {
4835            if !first {
4836                f.write_str(" | ")?;
4837            }
4838            f.write_str("DEVICE_ADDRESS_BINDING")?;
4839            remaining &= !Self::DEVICE_ADDRESS_BINDING.0;
4840            first = false;
4841        }
4842        if remaining != 0u32 {
4843            if !first {
4844                f.write_str(" | ")?;
4845            }
4846            write!(f, "{:#x}", remaining)?;
4847        } else if first {
4848            f.write_str("(empty)")?;
4849        }
4850        Ok(())
4851    }
4852}
4853///[`VkDependencyFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyFlagBits.html)
4854#[repr(transparent)]
4855#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
4856#[doc(alias = "VkDependencyFlagBits")]
4857pub struct DependencyFlagBits(u32);
4858impl DependencyFlagBits {
4859    #[inline]
4860    pub const fn empty() -> Self {
4861        Self(0u32)
4862    }
4863    #[inline]
4864    pub const fn from_raw(value: u32) -> Self {
4865        Self(value)
4866    }
4867    #[inline]
4868    pub const fn as_raw(self) -> u32 {
4869        self.0
4870    }
4871    #[inline]
4872    pub const fn is_empty(self) -> bool {
4873        self.0 == 0u32
4874    }
4875    #[inline]
4876    pub const fn contains(self, other: Self) -> bool {
4877        (self.0 & other.0) == other.0
4878    }
4879    ///Bit 0.
4880    pub const BY_REGION: Self = Self(1u32);
4881    ///Bit 2.
4882    pub const DEVICE_GROUP: Self = Self(4u32);
4883    ///Bit 1.
4884    pub const VIEW_LOCAL: Self = Self(2u32);
4885    ///Bit 3.
4886    pub const FEEDBACK_LOOP: Self = Self(8u32);
4887    ///Bit 5.
4888    pub const QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES: Self = Self(32u32);
4889    ///Bit 6.
4890    pub const ASYMMETRIC_EVENT: Self = Self(64u32);
4891}
4892impl core::ops::BitOr for DependencyFlagBits {
4893    type Output = Self;
4894    #[inline]
4895    fn bitor(self, rhs: Self) -> Self {
4896        Self(self.0 | rhs.0)
4897    }
4898}
4899impl core::ops::BitOrAssign for DependencyFlagBits {
4900    #[inline]
4901    fn bitor_assign(&mut self, rhs: Self) {
4902        self.0 |= rhs.0;
4903    }
4904}
4905impl core::ops::BitAnd for DependencyFlagBits {
4906    type Output = Self;
4907    #[inline]
4908    fn bitand(self, rhs: Self) -> Self {
4909        Self(self.0 & rhs.0)
4910    }
4911}
4912impl core::ops::BitAndAssign for DependencyFlagBits {
4913    #[inline]
4914    fn bitand_assign(&mut self, rhs: Self) {
4915        self.0 &= rhs.0;
4916    }
4917}
4918impl core::ops::BitXor for DependencyFlagBits {
4919    type Output = Self;
4920    #[inline]
4921    fn bitxor(self, rhs: Self) -> Self {
4922        Self(self.0 ^ rhs.0)
4923    }
4924}
4925impl core::ops::BitXorAssign for DependencyFlagBits {
4926    #[inline]
4927    fn bitxor_assign(&mut self, rhs: Self) {
4928        self.0 ^= rhs.0;
4929    }
4930}
4931impl core::ops::Not for DependencyFlagBits {
4932    type Output = Self;
4933    #[inline]
4934    fn not(self) -> Self {
4935        Self(!self.0)
4936    }
4937}
4938impl core::fmt::Debug for DependencyFlagBits {
4939    #[allow(unused_mut, unused_variables)]
4940    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4941        let mut first = true;
4942        let mut remaining = self.0;
4943        if remaining & Self::BY_REGION.0 != 0 {
4944            if !first {
4945                f.write_str(" | ")?;
4946            }
4947            f.write_str("BY_REGION")?;
4948            remaining &= !Self::BY_REGION.0;
4949            first = false;
4950        }
4951        if remaining & Self::DEVICE_GROUP.0 != 0 {
4952            if !first {
4953                f.write_str(" | ")?;
4954            }
4955            f.write_str("DEVICE_GROUP")?;
4956            remaining &= !Self::DEVICE_GROUP.0;
4957            first = false;
4958        }
4959        if remaining & Self::VIEW_LOCAL.0 != 0 {
4960            if !first {
4961                f.write_str(" | ")?;
4962            }
4963            f.write_str("VIEW_LOCAL")?;
4964            remaining &= !Self::VIEW_LOCAL.0;
4965            first = false;
4966        }
4967        if remaining & Self::FEEDBACK_LOOP.0 != 0 {
4968            if !first {
4969                f.write_str(" | ")?;
4970            }
4971            f.write_str("FEEDBACK_LOOP")?;
4972            remaining &= !Self::FEEDBACK_LOOP.0;
4973            first = false;
4974        }
4975        if remaining & Self::QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES.0 != 0 {
4976            if !first {
4977                f.write_str(" | ")?;
4978            }
4979            f.write_str("QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES")?;
4980            remaining &= !Self::QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES.0;
4981            first = false;
4982        }
4983        if remaining & Self::ASYMMETRIC_EVENT.0 != 0 {
4984            if !first {
4985                f.write_str(" | ")?;
4986            }
4987            f.write_str("ASYMMETRIC_EVENT")?;
4988            remaining &= !Self::ASYMMETRIC_EVENT.0;
4989            first = false;
4990        }
4991        if remaining != 0u32 {
4992            if !first {
4993                f.write_str(" | ")?;
4994            }
4995            write!(f, "{:#x}", remaining)?;
4996        } else if first {
4997            f.write_str("(empty)")?;
4998        }
4999        Ok(())
5000    }
5001}
5002///[`VkDescriptorBindingFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBindingFlagBits.html)
5003#[repr(transparent)]
5004#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
5005#[doc(alias = "VkDescriptorBindingFlagBits")]
5006pub struct DescriptorBindingFlagBits(u32);
5007impl DescriptorBindingFlagBits {
5008    #[inline]
5009    pub const fn empty() -> Self {
5010        Self(0u32)
5011    }
5012    #[inline]
5013    pub const fn from_raw(value: u32) -> Self {
5014        Self(value)
5015    }
5016    #[inline]
5017    pub const fn as_raw(self) -> u32 {
5018        self.0
5019    }
5020    #[inline]
5021    pub const fn is_empty(self) -> bool {
5022        self.0 == 0u32
5023    }
5024    #[inline]
5025    pub const fn contains(self, other: Self) -> bool {
5026        (self.0 & other.0) == other.0
5027    }
5028    ///Bit 0.
5029    pub const UPDATE_AFTER_BIND: Self = Self(1u32);
5030    ///Bit 1.
5031    pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(2u32);
5032    ///Bit 2.
5033    pub const PARTIALLY_BOUND: Self = Self(4u32);
5034    ///Bit 3.
5035    pub const VARIABLE_DESCRIPTOR_COUNT: Self = Self(8u32);
5036}
5037impl core::ops::BitOr for DescriptorBindingFlagBits {
5038    type Output = Self;
5039    #[inline]
5040    fn bitor(self, rhs: Self) -> Self {
5041        Self(self.0 | rhs.0)
5042    }
5043}
5044impl core::ops::BitOrAssign for DescriptorBindingFlagBits {
5045    #[inline]
5046    fn bitor_assign(&mut self, rhs: Self) {
5047        self.0 |= rhs.0;
5048    }
5049}
5050impl core::ops::BitAnd for DescriptorBindingFlagBits {
5051    type Output = Self;
5052    #[inline]
5053    fn bitand(self, rhs: Self) -> Self {
5054        Self(self.0 & rhs.0)
5055    }
5056}
5057impl core::ops::BitAndAssign for DescriptorBindingFlagBits {
5058    #[inline]
5059    fn bitand_assign(&mut self, rhs: Self) {
5060        self.0 &= rhs.0;
5061    }
5062}
5063impl core::ops::BitXor for DescriptorBindingFlagBits {
5064    type Output = Self;
5065    #[inline]
5066    fn bitxor(self, rhs: Self) -> Self {
5067        Self(self.0 ^ rhs.0)
5068    }
5069}
5070impl core::ops::BitXorAssign for DescriptorBindingFlagBits {
5071    #[inline]
5072    fn bitxor_assign(&mut self, rhs: Self) {
5073        self.0 ^= rhs.0;
5074    }
5075}
5076impl core::ops::Not for DescriptorBindingFlagBits {
5077    type Output = Self;
5078    #[inline]
5079    fn not(self) -> Self {
5080        Self(!self.0)
5081    }
5082}
5083impl core::fmt::Debug for DescriptorBindingFlagBits {
5084    #[allow(unused_mut, unused_variables)]
5085    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5086        let mut first = true;
5087        let mut remaining = self.0;
5088        if remaining & Self::UPDATE_AFTER_BIND.0 != 0 {
5089            if !first {
5090                f.write_str(" | ")?;
5091            }
5092            f.write_str("UPDATE_AFTER_BIND")?;
5093            remaining &= !Self::UPDATE_AFTER_BIND.0;
5094            first = false;
5095        }
5096        if remaining & Self::UPDATE_UNUSED_WHILE_PENDING.0 != 0 {
5097            if !first {
5098                f.write_str(" | ")?;
5099            }
5100            f.write_str("UPDATE_UNUSED_WHILE_PENDING")?;
5101            remaining &= !Self::UPDATE_UNUSED_WHILE_PENDING.0;
5102            first = false;
5103        }
5104        if remaining & Self::PARTIALLY_BOUND.0 != 0 {
5105            if !first {
5106                f.write_str(" | ")?;
5107            }
5108            f.write_str("PARTIALLY_BOUND")?;
5109            remaining &= !Self::PARTIALLY_BOUND.0;
5110            first = false;
5111        }
5112        if remaining & Self::VARIABLE_DESCRIPTOR_COUNT.0 != 0 {
5113            if !first {
5114                f.write_str(" | ")?;
5115            }
5116            f.write_str("VARIABLE_DESCRIPTOR_COUNT")?;
5117            remaining &= !Self::VARIABLE_DESCRIPTOR_COUNT.0;
5118            first = false;
5119        }
5120        if remaining != 0u32 {
5121            if !first {
5122                f.write_str(" | ")?;
5123            }
5124            write!(f, "{:#x}", remaining)?;
5125        } else if first {
5126            f.write_str("(empty)")?;
5127        }
5128        Ok(())
5129    }
5130}
5131///[`VkDescriptorPoolCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateFlagBits.html)
5132#[repr(transparent)]
5133#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
5134#[doc(alias = "VkDescriptorPoolCreateFlagBits")]
5135pub struct DescriptorPoolCreateFlagBits(u32);
5136impl DescriptorPoolCreateFlagBits {
5137    #[inline]
5138    pub const fn empty() -> Self {
5139        Self(0u32)
5140    }
5141    #[inline]
5142    pub const fn from_raw(value: u32) -> Self {
5143        Self(value)
5144    }
5145    #[inline]
5146    pub const fn as_raw(self) -> u32 {
5147        self.0
5148    }
5149    #[inline]
5150    pub const fn is_empty(self) -> bool {
5151        self.0 == 0u32
5152    }
5153    #[inline]
5154    pub const fn contains(self, other: Self) -> bool {
5155        (self.0 & other.0) == other.0
5156    }
5157    ///Bit 0.
5158    pub const FREE_DESCRIPTOR_SET: Self = Self(1u32);
5159    ///Bit 1.
5160    pub const UPDATE_AFTER_BIND: Self = Self(2u32);
5161    pub const HOST_ONLY_BIT: Self = Self::HOST_ONLY;
5162    ///Bit 2.
5163    pub const HOST_ONLY: Self = Self(4u32);
5164    ///Bit 3.
5165    pub const ALLOW_OVERALLOCATION_SETS: Self = Self(8u32);
5166    ///Bit 4.
5167    pub const ALLOW_OVERALLOCATION_POOLS: Self = Self(16u32);
5168}
5169impl core::ops::BitOr for DescriptorPoolCreateFlagBits {
5170    type Output = Self;
5171    #[inline]
5172    fn bitor(self, rhs: Self) -> Self {
5173        Self(self.0 | rhs.0)
5174    }
5175}
5176impl core::ops::BitOrAssign for DescriptorPoolCreateFlagBits {
5177    #[inline]
5178    fn bitor_assign(&mut self, rhs: Self) {
5179        self.0 |= rhs.0;
5180    }
5181}
5182impl core::ops::BitAnd for DescriptorPoolCreateFlagBits {
5183    type Output = Self;
5184    #[inline]
5185    fn bitand(self, rhs: Self) -> Self {
5186        Self(self.0 & rhs.0)
5187    }
5188}
5189impl core::ops::BitAndAssign for DescriptorPoolCreateFlagBits {
5190    #[inline]
5191    fn bitand_assign(&mut self, rhs: Self) {
5192        self.0 &= rhs.0;
5193    }
5194}
5195impl core::ops::BitXor for DescriptorPoolCreateFlagBits {
5196    type Output = Self;
5197    #[inline]
5198    fn bitxor(self, rhs: Self) -> Self {
5199        Self(self.0 ^ rhs.0)
5200    }
5201}
5202impl core::ops::BitXorAssign for DescriptorPoolCreateFlagBits {
5203    #[inline]
5204    fn bitxor_assign(&mut self, rhs: Self) {
5205        self.0 ^= rhs.0;
5206    }
5207}
5208impl core::ops::Not for DescriptorPoolCreateFlagBits {
5209    type Output = Self;
5210    #[inline]
5211    fn not(self) -> Self {
5212        Self(!self.0)
5213    }
5214}
5215impl core::fmt::Debug for DescriptorPoolCreateFlagBits {
5216    #[allow(unused_mut, unused_variables)]
5217    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5218        let mut first = true;
5219        let mut remaining = self.0;
5220        if remaining & Self::FREE_DESCRIPTOR_SET.0 != 0 {
5221            if !first {
5222                f.write_str(" | ")?;
5223            }
5224            f.write_str("FREE_DESCRIPTOR_SET")?;
5225            remaining &= !Self::FREE_DESCRIPTOR_SET.0;
5226            first = false;
5227        }
5228        if remaining & Self::UPDATE_AFTER_BIND.0 != 0 {
5229            if !first {
5230                f.write_str(" | ")?;
5231            }
5232            f.write_str("UPDATE_AFTER_BIND")?;
5233            remaining &= !Self::UPDATE_AFTER_BIND.0;
5234            first = false;
5235        }
5236        if remaining & Self::HOST_ONLY.0 != 0 {
5237            if !first {
5238                f.write_str(" | ")?;
5239            }
5240            f.write_str("HOST_ONLY")?;
5241            remaining &= !Self::HOST_ONLY.0;
5242            first = false;
5243        }
5244        if remaining & Self::ALLOW_OVERALLOCATION_SETS.0 != 0 {
5245            if !first {
5246                f.write_str(" | ")?;
5247            }
5248            f.write_str("ALLOW_OVERALLOCATION_SETS")?;
5249            remaining &= !Self::ALLOW_OVERALLOCATION_SETS.0;
5250            first = false;
5251        }
5252        if remaining & Self::ALLOW_OVERALLOCATION_POOLS.0 != 0 {
5253            if !first {
5254                f.write_str(" | ")?;
5255            }
5256            f.write_str("ALLOW_OVERALLOCATION_POOLS")?;
5257            remaining &= !Self::ALLOW_OVERALLOCATION_POOLS.0;
5258            first = false;
5259        }
5260        if remaining != 0u32 {
5261            if !first {
5262                f.write_str(" | ")?;
5263            }
5264            write!(f, "{:#x}", remaining)?;
5265        } else if first {
5266            f.write_str("(empty)")?;
5267        }
5268        Ok(())
5269    }
5270}
5271///[`VkDescriptorSetLayoutCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateFlagBits.html)
5272#[repr(transparent)]
5273#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
5274#[doc(alias = "VkDescriptorSetLayoutCreateFlagBits")]
5275pub struct DescriptorSetLayoutCreateFlagBits(u32);
5276impl DescriptorSetLayoutCreateFlagBits {
5277    #[inline]
5278    pub const fn empty() -> Self {
5279        Self(0u32)
5280    }
5281    #[inline]
5282    pub const fn from_raw(value: u32) -> Self {
5283        Self(value)
5284    }
5285    #[inline]
5286    pub const fn as_raw(self) -> u32 {
5287        self.0
5288    }
5289    #[inline]
5290    pub const fn is_empty(self) -> bool {
5291        self.0 == 0u32
5292    }
5293    #[inline]
5294    pub const fn contains(self, other: Self) -> bool {
5295        (self.0 & other.0) == other.0
5296    }
5297    ///Bit 1.
5298    pub const UPDATE_AFTER_BIND_POOL: Self = Self(2u32);
5299    ///Bit 0.
5300    pub const PUSH_DESCRIPTOR: Self = Self(1u32);
5301    ///Bit 4.
5302    pub const DESCRIPTOR_BUFFER: Self = Self(16u32);
5303    ///Bit 5.
5304    pub const EMBEDDED_IMMUTABLE_SAMPLERS: Self = Self(32u32);
5305    pub const HOST_ONLY_POOL_BIT: Self = Self::HOST_ONLY_POOL;
5306    ///Bit 7.
5307    pub const INDIRECT_BINDABLE: Self = Self(128u32);
5308    ///Bit 2.
5309    pub const HOST_ONLY_POOL: Self = Self(4u32);
5310    ///Bit 6.
5311    pub const PER_STAGE: Self = Self(64u32);
5312}
5313impl core::ops::BitOr for DescriptorSetLayoutCreateFlagBits {
5314    type Output = Self;
5315    #[inline]
5316    fn bitor(self, rhs: Self) -> Self {
5317        Self(self.0 | rhs.0)
5318    }
5319}
5320impl core::ops::BitOrAssign for DescriptorSetLayoutCreateFlagBits {
5321    #[inline]
5322    fn bitor_assign(&mut self, rhs: Self) {
5323        self.0 |= rhs.0;
5324    }
5325}
5326impl core::ops::BitAnd for DescriptorSetLayoutCreateFlagBits {
5327    type Output = Self;
5328    #[inline]
5329    fn bitand(self, rhs: Self) -> Self {
5330        Self(self.0 & rhs.0)
5331    }
5332}
5333impl core::ops::BitAndAssign for DescriptorSetLayoutCreateFlagBits {
5334    #[inline]
5335    fn bitand_assign(&mut self, rhs: Self) {
5336        self.0 &= rhs.0;
5337    }
5338}
5339impl core::ops::BitXor for DescriptorSetLayoutCreateFlagBits {
5340    type Output = Self;
5341    #[inline]
5342    fn bitxor(self, rhs: Self) -> Self {
5343        Self(self.0 ^ rhs.0)
5344    }
5345}
5346impl core::ops::BitXorAssign for DescriptorSetLayoutCreateFlagBits {
5347    #[inline]
5348    fn bitxor_assign(&mut self, rhs: Self) {
5349        self.0 ^= rhs.0;
5350    }
5351}
5352impl core::ops::Not for DescriptorSetLayoutCreateFlagBits {
5353    type Output = Self;
5354    #[inline]
5355    fn not(self) -> Self {
5356        Self(!self.0)
5357    }
5358}
5359impl core::fmt::Debug for DescriptorSetLayoutCreateFlagBits {
5360    #[allow(unused_mut, unused_variables)]
5361    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5362        let mut first = true;
5363        let mut remaining = self.0;
5364        if remaining & Self::UPDATE_AFTER_BIND_POOL.0 != 0 {
5365            if !first {
5366                f.write_str(" | ")?;
5367            }
5368            f.write_str("UPDATE_AFTER_BIND_POOL")?;
5369            remaining &= !Self::UPDATE_AFTER_BIND_POOL.0;
5370            first = false;
5371        }
5372        if remaining & Self::PUSH_DESCRIPTOR.0 != 0 {
5373            if !first {
5374                f.write_str(" | ")?;
5375            }
5376            f.write_str("PUSH_DESCRIPTOR")?;
5377            remaining &= !Self::PUSH_DESCRIPTOR.0;
5378            first = false;
5379        }
5380        if remaining & Self::DESCRIPTOR_BUFFER.0 != 0 {
5381            if !first {
5382                f.write_str(" | ")?;
5383            }
5384            f.write_str("DESCRIPTOR_BUFFER")?;
5385            remaining &= !Self::DESCRIPTOR_BUFFER.0;
5386            first = false;
5387        }
5388        if remaining & Self::EMBEDDED_IMMUTABLE_SAMPLERS.0 != 0 {
5389            if !first {
5390                f.write_str(" | ")?;
5391            }
5392            f.write_str("EMBEDDED_IMMUTABLE_SAMPLERS")?;
5393            remaining &= !Self::EMBEDDED_IMMUTABLE_SAMPLERS.0;
5394            first = false;
5395        }
5396        if remaining & Self::INDIRECT_BINDABLE.0 != 0 {
5397            if !first {
5398                f.write_str(" | ")?;
5399            }
5400            f.write_str("INDIRECT_BINDABLE")?;
5401            remaining &= !Self::INDIRECT_BINDABLE.0;
5402            first = false;
5403        }
5404        if remaining & Self::HOST_ONLY_POOL.0 != 0 {
5405            if !first {
5406                f.write_str(" | ")?;
5407            }
5408            f.write_str("HOST_ONLY_POOL")?;
5409            remaining &= !Self::HOST_ONLY_POOL.0;
5410            first = false;
5411        }
5412        if remaining & Self::PER_STAGE.0 != 0 {
5413            if !first {
5414                f.write_str(" | ")?;
5415            }
5416            f.write_str("PER_STAGE")?;
5417            remaining &= !Self::PER_STAGE.0;
5418            first = false;
5419        }
5420        if remaining != 0u32 {
5421            if !first {
5422                f.write_str(" | ")?;
5423            }
5424            write!(f, "{:#x}", remaining)?;
5425        } else if first {
5426            f.write_str("(empty)")?;
5427        }
5428        Ok(())
5429    }
5430}
5431///[`VkDeviceAddressBindingFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingFlagBitsEXT.html)
5432#[repr(transparent)]
5433#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
5434#[doc(alias = "VkDeviceAddressBindingFlagBitsEXT")]
5435pub struct DeviceAddressBindingFlagBitsEXT(u32);
5436impl DeviceAddressBindingFlagBitsEXT {
5437    #[inline]
5438    pub const fn empty() -> Self {
5439        Self(0u32)
5440    }
5441    #[inline]
5442    pub const fn from_raw(value: u32) -> Self {
5443        Self(value)
5444    }
5445    #[inline]
5446    pub const fn as_raw(self) -> u32 {
5447        self.0
5448    }
5449    #[inline]
5450    pub const fn is_empty(self) -> bool {
5451        self.0 == 0u32
5452    }
5453    #[inline]
5454    pub const fn contains(self, other: Self) -> bool {
5455        (self.0 & other.0) == other.0
5456    }
5457    ///Bit 0.
5458    pub const INTERNAL_OBJECT: Self = Self(1u32);
5459}
5460impl core::ops::BitOr for DeviceAddressBindingFlagBitsEXT {
5461    type Output = Self;
5462    #[inline]
5463    fn bitor(self, rhs: Self) -> Self {
5464        Self(self.0 | rhs.0)
5465    }
5466}
5467impl core::ops::BitOrAssign for DeviceAddressBindingFlagBitsEXT {
5468    #[inline]
5469    fn bitor_assign(&mut self, rhs: Self) {
5470        self.0 |= rhs.0;
5471    }
5472}
5473impl core::ops::BitAnd for DeviceAddressBindingFlagBitsEXT {
5474    type Output = Self;
5475    #[inline]
5476    fn bitand(self, rhs: Self) -> Self {
5477        Self(self.0 & rhs.0)
5478    }
5479}
5480impl core::ops::BitAndAssign for DeviceAddressBindingFlagBitsEXT {
5481    #[inline]
5482    fn bitand_assign(&mut self, rhs: Self) {
5483        self.0 &= rhs.0;
5484    }
5485}
5486impl core::ops::BitXor for DeviceAddressBindingFlagBitsEXT {
5487    type Output = Self;
5488    #[inline]
5489    fn bitxor(self, rhs: Self) -> Self {
5490        Self(self.0 ^ rhs.0)
5491    }
5492}
5493impl core::ops::BitXorAssign for DeviceAddressBindingFlagBitsEXT {
5494    #[inline]
5495    fn bitxor_assign(&mut self, rhs: Self) {
5496        self.0 ^= rhs.0;
5497    }
5498}
5499impl core::ops::Not for DeviceAddressBindingFlagBitsEXT {
5500    type Output = Self;
5501    #[inline]
5502    fn not(self) -> Self {
5503        Self(!self.0)
5504    }
5505}
5506impl core::fmt::Debug for DeviceAddressBindingFlagBitsEXT {
5507    #[allow(unused_mut, unused_variables)]
5508    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5509        let mut first = true;
5510        let mut remaining = self.0;
5511        if remaining & Self::INTERNAL_OBJECT.0 != 0 {
5512            if !first {
5513                f.write_str(" | ")?;
5514            }
5515            f.write_str("INTERNAL_OBJECT")?;
5516            remaining &= !Self::INTERNAL_OBJECT.0;
5517            first = false;
5518        }
5519        if remaining != 0u32 {
5520            if !first {
5521                f.write_str(" | ")?;
5522            }
5523            write!(f, "{:#x}", remaining)?;
5524        } else if first {
5525            f.write_str("(empty)")?;
5526        }
5527        Ok(())
5528    }
5529}
5530///[`VkDeviceDiagnosticsConfigFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html)
5531#[repr(transparent)]
5532#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
5533#[doc(alias = "VkDeviceDiagnosticsConfigFlagBitsNV")]
5534pub struct DeviceDiagnosticsConfigFlagBitsNV(u32);
5535impl DeviceDiagnosticsConfigFlagBitsNV {
5536    #[inline]
5537    pub const fn empty() -> Self {
5538        Self(0u32)
5539    }
5540    #[inline]
5541    pub const fn from_raw(value: u32) -> Self {
5542        Self(value)
5543    }
5544    #[inline]
5545    pub const fn as_raw(self) -> u32 {
5546        self.0
5547    }
5548    #[inline]
5549    pub const fn is_empty(self) -> bool {
5550        self.0 == 0u32
5551    }
5552    #[inline]
5553    pub const fn contains(self, other: Self) -> bool {
5554        (self.0 & other.0) == other.0
5555    }
5556    ///Bit 0.
5557    pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(1u32);
5558    ///Bit 1.
5559    pub const ENABLE_RESOURCE_TRACKING: Self = Self(2u32);
5560    ///Bit 2.
5561    pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(4u32);
5562    ///Bit 3.
5563    pub const ENABLE_SHADER_ERROR_REPORTING: Self = Self(8u32);
5564}
5565impl core::ops::BitOr for DeviceDiagnosticsConfigFlagBitsNV {
5566    type Output = Self;
5567    #[inline]
5568    fn bitor(self, rhs: Self) -> Self {
5569        Self(self.0 | rhs.0)
5570    }
5571}
5572impl core::ops::BitOrAssign for DeviceDiagnosticsConfigFlagBitsNV {
5573    #[inline]
5574    fn bitor_assign(&mut self, rhs: Self) {
5575        self.0 |= rhs.0;
5576    }
5577}
5578impl core::ops::BitAnd for DeviceDiagnosticsConfigFlagBitsNV {
5579    type Output = Self;
5580    #[inline]
5581    fn bitand(self, rhs: Self) -> Self {
5582        Self(self.0 & rhs.0)
5583    }
5584}
5585impl core::ops::BitAndAssign for DeviceDiagnosticsConfigFlagBitsNV {
5586    #[inline]
5587    fn bitand_assign(&mut self, rhs: Self) {
5588        self.0 &= rhs.0;
5589    }
5590}
5591impl core::ops::BitXor for DeviceDiagnosticsConfigFlagBitsNV {
5592    type Output = Self;
5593    #[inline]
5594    fn bitxor(self, rhs: Self) -> Self {
5595        Self(self.0 ^ rhs.0)
5596    }
5597}
5598impl core::ops::BitXorAssign for DeviceDiagnosticsConfigFlagBitsNV {
5599    #[inline]
5600    fn bitxor_assign(&mut self, rhs: Self) {
5601        self.0 ^= rhs.0;
5602    }
5603}
5604impl core::ops::Not for DeviceDiagnosticsConfigFlagBitsNV {
5605    type Output = Self;
5606    #[inline]
5607    fn not(self) -> Self {
5608        Self(!self.0)
5609    }
5610}
5611impl core::fmt::Debug for DeviceDiagnosticsConfigFlagBitsNV {
5612    #[allow(unused_mut, unused_variables)]
5613    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5614        let mut first = true;
5615        let mut remaining = self.0;
5616        if remaining & Self::ENABLE_SHADER_DEBUG_INFO.0 != 0 {
5617            if !first {
5618                f.write_str(" | ")?;
5619            }
5620            f.write_str("ENABLE_SHADER_DEBUG_INFO")?;
5621            remaining &= !Self::ENABLE_SHADER_DEBUG_INFO.0;
5622            first = false;
5623        }
5624        if remaining & Self::ENABLE_RESOURCE_TRACKING.0 != 0 {
5625            if !first {
5626                f.write_str(" | ")?;
5627            }
5628            f.write_str("ENABLE_RESOURCE_TRACKING")?;
5629            remaining &= !Self::ENABLE_RESOURCE_TRACKING.0;
5630            first = false;
5631        }
5632        if remaining & Self::ENABLE_AUTOMATIC_CHECKPOINTS.0 != 0 {
5633            if !first {
5634                f.write_str(" | ")?;
5635            }
5636            f.write_str("ENABLE_AUTOMATIC_CHECKPOINTS")?;
5637            remaining &= !Self::ENABLE_AUTOMATIC_CHECKPOINTS.0;
5638            first = false;
5639        }
5640        if remaining & Self::ENABLE_SHADER_ERROR_REPORTING.0 != 0 {
5641            if !first {
5642                f.write_str(" | ")?;
5643            }
5644            f.write_str("ENABLE_SHADER_ERROR_REPORTING")?;
5645            remaining &= !Self::ENABLE_SHADER_ERROR_REPORTING.0;
5646            first = false;
5647        }
5648        if remaining != 0u32 {
5649            if !first {
5650                f.write_str(" | ")?;
5651            }
5652            write!(f, "{:#x}", remaining)?;
5653        } else if first {
5654            f.write_str("(empty)")?;
5655        }
5656        Ok(())
5657    }
5658}
5659///[`VkDeviceFaultFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultFlagBitsKHR.html)
5660#[repr(transparent)]
5661#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
5662#[doc(alias = "VkDeviceFaultFlagBitsKHR")]
5663pub struct DeviceFaultFlagBitsKHR(u32);
5664impl DeviceFaultFlagBitsKHR {
5665    #[inline]
5666    pub const fn empty() -> Self {
5667        Self(0u32)
5668    }
5669    #[inline]
5670    pub const fn from_raw(value: u32) -> Self {
5671        Self(value)
5672    }
5673    #[inline]
5674    pub const fn as_raw(self) -> u32 {
5675        self.0
5676    }
5677    #[inline]
5678    pub const fn is_empty(self) -> bool {
5679        self.0 == 0u32
5680    }
5681    #[inline]
5682    pub const fn contains(self, other: Self) -> bool {
5683        (self.0 & other.0) == other.0
5684    }
5685    ///Bit 0.
5686    pub const FLAG_DEVICE_LOST: Self = Self(1u32);
5687    ///Bit 1.
5688    pub const FLAG_MEMORY_ADDRESS: Self = Self(2u32);
5689    ///Bit 2.
5690    pub const FLAG_INSTRUCTION_ADDRESS: Self = Self(4u32);
5691    ///Bit 3.
5692    pub const FLAG_VENDOR: Self = Self(8u32);
5693    ///Bit 4.
5694    pub const FLAG_WATCHDOG_TIMEOUT: Self = Self(16u32);
5695    ///Bit 5.
5696    pub const FLAG_OVERFLOW: Self = Self(32u32);
5697}
5698impl core::ops::BitOr for DeviceFaultFlagBitsKHR {
5699    type Output = Self;
5700    #[inline]
5701    fn bitor(self, rhs: Self) -> Self {
5702        Self(self.0 | rhs.0)
5703    }
5704}
5705impl core::ops::BitOrAssign for DeviceFaultFlagBitsKHR {
5706    #[inline]
5707    fn bitor_assign(&mut self, rhs: Self) {
5708        self.0 |= rhs.0;
5709    }
5710}
5711impl core::ops::BitAnd for DeviceFaultFlagBitsKHR {
5712    type Output = Self;
5713    #[inline]
5714    fn bitand(self, rhs: Self) -> Self {
5715        Self(self.0 & rhs.0)
5716    }
5717}
5718impl core::ops::BitAndAssign for DeviceFaultFlagBitsKHR {
5719    #[inline]
5720    fn bitand_assign(&mut self, rhs: Self) {
5721        self.0 &= rhs.0;
5722    }
5723}
5724impl core::ops::BitXor for DeviceFaultFlagBitsKHR {
5725    type Output = Self;
5726    #[inline]
5727    fn bitxor(self, rhs: Self) -> Self {
5728        Self(self.0 ^ rhs.0)
5729    }
5730}
5731impl core::ops::BitXorAssign for DeviceFaultFlagBitsKHR {
5732    #[inline]
5733    fn bitxor_assign(&mut self, rhs: Self) {
5734        self.0 ^= rhs.0;
5735    }
5736}
5737impl core::ops::Not for DeviceFaultFlagBitsKHR {
5738    type Output = Self;
5739    #[inline]
5740    fn not(self) -> Self {
5741        Self(!self.0)
5742    }
5743}
5744impl core::fmt::Debug for DeviceFaultFlagBitsKHR {
5745    #[allow(unused_mut, unused_variables)]
5746    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5747        let mut first = true;
5748        let mut remaining = self.0;
5749        if remaining & Self::FLAG_DEVICE_LOST.0 != 0 {
5750            if !first {
5751                f.write_str(" | ")?;
5752            }
5753            f.write_str("FLAG_DEVICE_LOST")?;
5754            remaining &= !Self::FLAG_DEVICE_LOST.0;
5755            first = false;
5756        }
5757        if remaining & Self::FLAG_MEMORY_ADDRESS.0 != 0 {
5758            if !first {
5759                f.write_str(" | ")?;
5760            }
5761            f.write_str("FLAG_MEMORY_ADDRESS")?;
5762            remaining &= !Self::FLAG_MEMORY_ADDRESS.0;
5763            first = false;
5764        }
5765        if remaining & Self::FLAG_INSTRUCTION_ADDRESS.0 != 0 {
5766            if !first {
5767                f.write_str(" | ")?;
5768            }
5769            f.write_str("FLAG_INSTRUCTION_ADDRESS")?;
5770            remaining &= !Self::FLAG_INSTRUCTION_ADDRESS.0;
5771            first = false;
5772        }
5773        if remaining & Self::FLAG_VENDOR.0 != 0 {
5774            if !first {
5775                f.write_str(" | ")?;
5776            }
5777            f.write_str("FLAG_VENDOR")?;
5778            remaining &= !Self::FLAG_VENDOR.0;
5779            first = false;
5780        }
5781        if remaining & Self::FLAG_WATCHDOG_TIMEOUT.0 != 0 {
5782            if !first {
5783                f.write_str(" | ")?;
5784            }
5785            f.write_str("FLAG_WATCHDOG_TIMEOUT")?;
5786            remaining &= !Self::FLAG_WATCHDOG_TIMEOUT.0;
5787            first = false;
5788        }
5789        if remaining & Self::FLAG_OVERFLOW.0 != 0 {
5790            if !first {
5791                f.write_str(" | ")?;
5792            }
5793            f.write_str("FLAG_OVERFLOW")?;
5794            remaining &= !Self::FLAG_OVERFLOW.0;
5795            first = false;
5796        }
5797        if remaining != 0u32 {
5798            if !first {
5799                f.write_str(" | ")?;
5800            }
5801            write!(f, "{:#x}", remaining)?;
5802        } else if first {
5803            f.write_str("(empty)")?;
5804        }
5805        Ok(())
5806    }
5807}
5808///[`VkDeviceGroupPresentModeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html)
5809#[repr(transparent)]
5810#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
5811#[doc(alias = "VkDeviceGroupPresentModeFlagBitsKHR")]
5812pub struct DeviceGroupPresentModeFlagBitsKHR(u32);
5813impl DeviceGroupPresentModeFlagBitsKHR {
5814    #[inline]
5815    pub const fn empty() -> Self {
5816        Self(0u32)
5817    }
5818    #[inline]
5819    pub const fn from_raw(value: u32) -> Self {
5820        Self(value)
5821    }
5822    #[inline]
5823    pub const fn as_raw(self) -> u32 {
5824        self.0
5825    }
5826    #[inline]
5827    pub const fn is_empty(self) -> bool {
5828        self.0 == 0u32
5829    }
5830    #[inline]
5831    pub const fn contains(self, other: Self) -> bool {
5832        (self.0 & other.0) == other.0
5833    }
5834    ///Bit 0.
5835    pub const LOCAL: Self = Self(1u32);
5836    ///Bit 1.
5837    pub const REMOTE: Self = Self(2u32);
5838    ///Bit 2.
5839    pub const SUM: Self = Self(4u32);
5840    ///Bit 3.
5841    pub const LOCAL_MULTI_DEVICE: Self = Self(8u32);
5842}
5843impl core::ops::BitOr for DeviceGroupPresentModeFlagBitsKHR {
5844    type Output = Self;
5845    #[inline]
5846    fn bitor(self, rhs: Self) -> Self {
5847        Self(self.0 | rhs.0)
5848    }
5849}
5850impl core::ops::BitOrAssign for DeviceGroupPresentModeFlagBitsKHR {
5851    #[inline]
5852    fn bitor_assign(&mut self, rhs: Self) {
5853        self.0 |= rhs.0;
5854    }
5855}
5856impl core::ops::BitAnd for DeviceGroupPresentModeFlagBitsKHR {
5857    type Output = Self;
5858    #[inline]
5859    fn bitand(self, rhs: Self) -> Self {
5860        Self(self.0 & rhs.0)
5861    }
5862}
5863impl core::ops::BitAndAssign for DeviceGroupPresentModeFlagBitsKHR {
5864    #[inline]
5865    fn bitand_assign(&mut self, rhs: Self) {
5866        self.0 &= rhs.0;
5867    }
5868}
5869impl core::ops::BitXor for DeviceGroupPresentModeFlagBitsKHR {
5870    type Output = Self;
5871    #[inline]
5872    fn bitxor(self, rhs: Self) -> Self {
5873        Self(self.0 ^ rhs.0)
5874    }
5875}
5876impl core::ops::BitXorAssign for DeviceGroupPresentModeFlagBitsKHR {
5877    #[inline]
5878    fn bitxor_assign(&mut self, rhs: Self) {
5879        self.0 ^= rhs.0;
5880    }
5881}
5882impl core::ops::Not for DeviceGroupPresentModeFlagBitsKHR {
5883    type Output = Self;
5884    #[inline]
5885    fn not(self) -> Self {
5886        Self(!self.0)
5887    }
5888}
5889impl core::fmt::Debug for DeviceGroupPresentModeFlagBitsKHR {
5890    #[allow(unused_mut, unused_variables)]
5891    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5892        let mut first = true;
5893        let mut remaining = self.0;
5894        if remaining & Self::LOCAL.0 != 0 {
5895            if !first {
5896                f.write_str(" | ")?;
5897            }
5898            f.write_str("LOCAL")?;
5899            remaining &= !Self::LOCAL.0;
5900            first = false;
5901        }
5902        if remaining & Self::REMOTE.0 != 0 {
5903            if !first {
5904                f.write_str(" | ")?;
5905            }
5906            f.write_str("REMOTE")?;
5907            remaining &= !Self::REMOTE.0;
5908            first = false;
5909        }
5910        if remaining & Self::SUM.0 != 0 {
5911            if !first {
5912                f.write_str(" | ")?;
5913            }
5914            f.write_str("SUM")?;
5915            remaining &= !Self::SUM.0;
5916            first = false;
5917        }
5918        if remaining & Self::LOCAL_MULTI_DEVICE.0 != 0 {
5919            if !first {
5920                f.write_str(" | ")?;
5921            }
5922            f.write_str("LOCAL_MULTI_DEVICE")?;
5923            remaining &= !Self::LOCAL_MULTI_DEVICE.0;
5924            first = false;
5925        }
5926        if remaining != 0u32 {
5927            if !first {
5928                f.write_str(" | ")?;
5929            }
5930            write!(f, "{:#x}", remaining)?;
5931        } else if first {
5932            f.write_str("(empty)")?;
5933        }
5934        Ok(())
5935    }
5936}
5937///[`VkDeviceQueueCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateFlagBits.html)
5938#[repr(transparent)]
5939#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
5940#[doc(alias = "VkDeviceQueueCreateFlagBits")]
5941pub struct DeviceQueueCreateFlagBits(u32);
5942impl DeviceQueueCreateFlagBits {
5943    #[inline]
5944    pub const fn empty() -> Self {
5945        Self(0u32)
5946    }
5947    #[inline]
5948    pub const fn from_raw(value: u32) -> Self {
5949        Self(value)
5950    }
5951    #[inline]
5952    pub const fn as_raw(self) -> u32 {
5953        self.0
5954    }
5955    #[inline]
5956    pub const fn is_empty(self) -> bool {
5957        self.0 == 0u32
5958    }
5959    #[inline]
5960    pub const fn contains(self, other: Self) -> bool {
5961        (self.0 & other.0) == other.0
5962    }
5963    ///Bit 0.
5964    pub const PROTECTED: Self = Self(1u32);
5965    ///Bit 2.
5966    pub const INTERNALLY_SYNCHRONIZED: Self = Self(4u32);
5967}
5968impl core::ops::BitOr for DeviceQueueCreateFlagBits {
5969    type Output = Self;
5970    #[inline]
5971    fn bitor(self, rhs: Self) -> Self {
5972        Self(self.0 | rhs.0)
5973    }
5974}
5975impl core::ops::BitOrAssign for DeviceQueueCreateFlagBits {
5976    #[inline]
5977    fn bitor_assign(&mut self, rhs: Self) {
5978        self.0 |= rhs.0;
5979    }
5980}
5981impl core::ops::BitAnd for DeviceQueueCreateFlagBits {
5982    type Output = Self;
5983    #[inline]
5984    fn bitand(self, rhs: Self) -> Self {
5985        Self(self.0 & rhs.0)
5986    }
5987}
5988impl core::ops::BitAndAssign for DeviceQueueCreateFlagBits {
5989    #[inline]
5990    fn bitand_assign(&mut self, rhs: Self) {
5991        self.0 &= rhs.0;
5992    }
5993}
5994impl core::ops::BitXor for DeviceQueueCreateFlagBits {
5995    type Output = Self;
5996    #[inline]
5997    fn bitxor(self, rhs: Self) -> Self {
5998        Self(self.0 ^ rhs.0)
5999    }
6000}
6001impl core::ops::BitXorAssign for DeviceQueueCreateFlagBits {
6002    #[inline]
6003    fn bitxor_assign(&mut self, rhs: Self) {
6004        self.0 ^= rhs.0;
6005    }
6006}
6007impl core::ops::Not for DeviceQueueCreateFlagBits {
6008    type Output = Self;
6009    #[inline]
6010    fn not(self) -> Self {
6011        Self(!self.0)
6012    }
6013}
6014impl core::fmt::Debug for DeviceQueueCreateFlagBits {
6015    #[allow(unused_mut, unused_variables)]
6016    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6017        let mut first = true;
6018        let mut remaining = self.0;
6019        if remaining & Self::PROTECTED.0 != 0 {
6020            if !first {
6021                f.write_str(" | ")?;
6022            }
6023            f.write_str("PROTECTED")?;
6024            remaining &= !Self::PROTECTED.0;
6025            first = false;
6026        }
6027        if remaining & Self::INTERNALLY_SYNCHRONIZED.0 != 0 {
6028            if !first {
6029                f.write_str(" | ")?;
6030            }
6031            f.write_str("INTERNALLY_SYNCHRONIZED")?;
6032            remaining &= !Self::INTERNALLY_SYNCHRONIZED.0;
6033            first = false;
6034        }
6035        if remaining != 0u32 {
6036            if !first {
6037                f.write_str(" | ")?;
6038            }
6039            write!(f, "{:#x}", remaining)?;
6040        } else if first {
6041            f.write_str("(empty)")?;
6042        }
6043        Ok(())
6044    }
6045}
6046///[`VkDisplayPlaneAlphaFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html)
6047#[repr(transparent)]
6048#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
6049#[doc(alias = "VkDisplayPlaneAlphaFlagBitsKHR")]
6050pub struct DisplayPlaneAlphaFlagBitsKHR(u32);
6051impl DisplayPlaneAlphaFlagBitsKHR {
6052    #[inline]
6053    pub const fn empty() -> Self {
6054        Self(0u32)
6055    }
6056    #[inline]
6057    pub const fn from_raw(value: u32) -> Self {
6058        Self(value)
6059    }
6060    #[inline]
6061    pub const fn as_raw(self) -> u32 {
6062        self.0
6063    }
6064    #[inline]
6065    pub const fn is_empty(self) -> bool {
6066        self.0 == 0u32
6067    }
6068    #[inline]
6069    pub const fn contains(self, other: Self) -> bool {
6070        (self.0 & other.0) == other.0
6071    }
6072    ///Bit 0.
6073    pub const OPAQUE: Self = Self(1u32);
6074    ///Bit 1.
6075    pub const GLOBAL: Self = Self(2u32);
6076    ///Bit 2.
6077    pub const PER_PIXEL: Self = Self(4u32);
6078    ///Bit 3.
6079    pub const PER_PIXEL_PREMULTIPLIED: Self = Self(8u32);
6080}
6081impl core::ops::BitOr for DisplayPlaneAlphaFlagBitsKHR {
6082    type Output = Self;
6083    #[inline]
6084    fn bitor(self, rhs: Self) -> Self {
6085        Self(self.0 | rhs.0)
6086    }
6087}
6088impl core::ops::BitOrAssign for DisplayPlaneAlphaFlagBitsKHR {
6089    #[inline]
6090    fn bitor_assign(&mut self, rhs: Self) {
6091        self.0 |= rhs.0;
6092    }
6093}
6094impl core::ops::BitAnd for DisplayPlaneAlphaFlagBitsKHR {
6095    type Output = Self;
6096    #[inline]
6097    fn bitand(self, rhs: Self) -> Self {
6098        Self(self.0 & rhs.0)
6099    }
6100}
6101impl core::ops::BitAndAssign for DisplayPlaneAlphaFlagBitsKHR {
6102    #[inline]
6103    fn bitand_assign(&mut self, rhs: Self) {
6104        self.0 &= rhs.0;
6105    }
6106}
6107impl core::ops::BitXor for DisplayPlaneAlphaFlagBitsKHR {
6108    type Output = Self;
6109    #[inline]
6110    fn bitxor(self, rhs: Self) -> Self {
6111        Self(self.0 ^ rhs.0)
6112    }
6113}
6114impl core::ops::BitXorAssign for DisplayPlaneAlphaFlagBitsKHR {
6115    #[inline]
6116    fn bitxor_assign(&mut self, rhs: Self) {
6117        self.0 ^= rhs.0;
6118    }
6119}
6120impl core::ops::Not for DisplayPlaneAlphaFlagBitsKHR {
6121    type Output = Self;
6122    #[inline]
6123    fn not(self) -> Self {
6124        Self(!self.0)
6125    }
6126}
6127impl core::fmt::Debug for DisplayPlaneAlphaFlagBitsKHR {
6128    #[allow(unused_mut, unused_variables)]
6129    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6130        let mut first = true;
6131        let mut remaining = self.0;
6132        if remaining & Self::OPAQUE.0 != 0 {
6133            if !first {
6134                f.write_str(" | ")?;
6135            }
6136            f.write_str("OPAQUE")?;
6137            remaining &= !Self::OPAQUE.0;
6138            first = false;
6139        }
6140        if remaining & Self::GLOBAL.0 != 0 {
6141            if !first {
6142                f.write_str(" | ")?;
6143            }
6144            f.write_str("GLOBAL")?;
6145            remaining &= !Self::GLOBAL.0;
6146            first = false;
6147        }
6148        if remaining & Self::PER_PIXEL.0 != 0 {
6149            if !first {
6150                f.write_str(" | ")?;
6151            }
6152            f.write_str("PER_PIXEL")?;
6153            remaining &= !Self::PER_PIXEL.0;
6154            first = false;
6155        }
6156        if remaining & Self::PER_PIXEL_PREMULTIPLIED.0 != 0 {
6157            if !first {
6158                f.write_str(" | ")?;
6159            }
6160            f.write_str("PER_PIXEL_PREMULTIPLIED")?;
6161            remaining &= !Self::PER_PIXEL_PREMULTIPLIED.0;
6162            first = false;
6163        }
6164        if remaining != 0u32 {
6165            if !first {
6166                f.write_str(" | ")?;
6167            }
6168            write!(f, "{:#x}", remaining)?;
6169        } else if first {
6170            f.write_str("(empty)")?;
6171        }
6172        Ok(())
6173    }
6174}
6175///[`VkEventCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlagBits.html)
6176#[repr(transparent)]
6177#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
6178#[doc(alias = "VkEventCreateFlagBits")]
6179pub struct EventCreateFlagBits(u32);
6180impl EventCreateFlagBits {
6181    #[inline]
6182    pub const fn empty() -> Self {
6183        Self(0u32)
6184    }
6185    #[inline]
6186    pub const fn from_raw(value: u32) -> Self {
6187        Self(value)
6188    }
6189    #[inline]
6190    pub const fn as_raw(self) -> u32 {
6191        self.0
6192    }
6193    #[inline]
6194    pub const fn is_empty(self) -> bool {
6195        self.0 == 0u32
6196    }
6197    #[inline]
6198    pub const fn contains(self, other: Self) -> bool {
6199        (self.0 & other.0) == other.0
6200    }
6201    ///Bit 0.
6202    pub const DEVICE_ONLY: Self = Self(1u32);
6203}
6204impl core::ops::BitOr for EventCreateFlagBits {
6205    type Output = Self;
6206    #[inline]
6207    fn bitor(self, rhs: Self) -> Self {
6208        Self(self.0 | rhs.0)
6209    }
6210}
6211impl core::ops::BitOrAssign for EventCreateFlagBits {
6212    #[inline]
6213    fn bitor_assign(&mut self, rhs: Self) {
6214        self.0 |= rhs.0;
6215    }
6216}
6217impl core::ops::BitAnd for EventCreateFlagBits {
6218    type Output = Self;
6219    #[inline]
6220    fn bitand(self, rhs: Self) -> Self {
6221        Self(self.0 & rhs.0)
6222    }
6223}
6224impl core::ops::BitAndAssign for EventCreateFlagBits {
6225    #[inline]
6226    fn bitand_assign(&mut self, rhs: Self) {
6227        self.0 &= rhs.0;
6228    }
6229}
6230impl core::ops::BitXor for EventCreateFlagBits {
6231    type Output = Self;
6232    #[inline]
6233    fn bitxor(self, rhs: Self) -> Self {
6234        Self(self.0 ^ rhs.0)
6235    }
6236}
6237impl core::ops::BitXorAssign for EventCreateFlagBits {
6238    #[inline]
6239    fn bitxor_assign(&mut self, rhs: Self) {
6240        self.0 ^= rhs.0;
6241    }
6242}
6243impl core::ops::Not for EventCreateFlagBits {
6244    type Output = Self;
6245    #[inline]
6246    fn not(self) -> Self {
6247        Self(!self.0)
6248    }
6249}
6250impl core::fmt::Debug for EventCreateFlagBits {
6251    #[allow(unused_mut, unused_variables)]
6252    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6253        let mut first = true;
6254        let mut remaining = self.0;
6255        if remaining & Self::DEVICE_ONLY.0 != 0 {
6256            if !first {
6257                f.write_str(" | ")?;
6258            }
6259            f.write_str("DEVICE_ONLY")?;
6260            remaining &= !Self::DEVICE_ONLY.0;
6261            first = false;
6262        }
6263        if remaining != 0u32 {
6264            if !first {
6265                f.write_str(" | ")?;
6266            }
6267            write!(f, "{:#x}", remaining)?;
6268        } else if first {
6269            f.write_str("(empty)")?;
6270        }
6271        Ok(())
6272    }
6273}
6274///[`VkExportMetalObjectTypeFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectTypeFlagBitsEXT.html)
6275#[repr(transparent)]
6276#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
6277#[doc(alias = "VkExportMetalObjectTypeFlagBitsEXT")]
6278pub struct ExportMetalObjectTypeFlagBitsEXT(u32);
6279impl ExportMetalObjectTypeFlagBitsEXT {
6280    #[inline]
6281    pub const fn empty() -> Self {
6282        Self(0u32)
6283    }
6284    #[inline]
6285    pub const fn from_raw(value: u32) -> Self {
6286        Self(value)
6287    }
6288    #[inline]
6289    pub const fn as_raw(self) -> u32 {
6290        self.0
6291    }
6292    #[inline]
6293    pub const fn is_empty(self) -> bool {
6294        self.0 == 0u32
6295    }
6296    #[inline]
6297    pub const fn contains(self, other: Self) -> bool {
6298        (self.0 & other.0) == other.0
6299    }
6300    ///Bit 0.
6301    pub const METAL_DEVICE: Self = Self(1u32);
6302    ///Bit 1.
6303    pub const METAL_COMMAND_QUEUE: Self = Self(2u32);
6304    ///Bit 2.
6305    pub const METAL_BUFFER: Self = Self(4u32);
6306    ///Bit 3.
6307    pub const METAL_TEXTURE: Self = Self(8u32);
6308    ///Bit 4.
6309    pub const METAL_IOSURFACE: Self = Self(16u32);
6310    ///Bit 5.
6311    pub const METAL_SHARED_EVENT: Self = Self(32u32);
6312}
6313impl core::ops::BitOr for ExportMetalObjectTypeFlagBitsEXT {
6314    type Output = Self;
6315    #[inline]
6316    fn bitor(self, rhs: Self) -> Self {
6317        Self(self.0 | rhs.0)
6318    }
6319}
6320impl core::ops::BitOrAssign for ExportMetalObjectTypeFlagBitsEXT {
6321    #[inline]
6322    fn bitor_assign(&mut self, rhs: Self) {
6323        self.0 |= rhs.0;
6324    }
6325}
6326impl core::ops::BitAnd for ExportMetalObjectTypeFlagBitsEXT {
6327    type Output = Self;
6328    #[inline]
6329    fn bitand(self, rhs: Self) -> Self {
6330        Self(self.0 & rhs.0)
6331    }
6332}
6333impl core::ops::BitAndAssign for ExportMetalObjectTypeFlagBitsEXT {
6334    #[inline]
6335    fn bitand_assign(&mut self, rhs: Self) {
6336        self.0 &= rhs.0;
6337    }
6338}
6339impl core::ops::BitXor for ExportMetalObjectTypeFlagBitsEXT {
6340    type Output = Self;
6341    #[inline]
6342    fn bitxor(self, rhs: Self) -> Self {
6343        Self(self.0 ^ rhs.0)
6344    }
6345}
6346impl core::ops::BitXorAssign for ExportMetalObjectTypeFlagBitsEXT {
6347    #[inline]
6348    fn bitxor_assign(&mut self, rhs: Self) {
6349        self.0 ^= rhs.0;
6350    }
6351}
6352impl core::ops::Not for ExportMetalObjectTypeFlagBitsEXT {
6353    type Output = Self;
6354    #[inline]
6355    fn not(self) -> Self {
6356        Self(!self.0)
6357    }
6358}
6359impl core::fmt::Debug for ExportMetalObjectTypeFlagBitsEXT {
6360    #[allow(unused_mut, unused_variables)]
6361    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6362        let mut first = true;
6363        let mut remaining = self.0;
6364        if remaining & Self::METAL_DEVICE.0 != 0 {
6365            if !first {
6366                f.write_str(" | ")?;
6367            }
6368            f.write_str("METAL_DEVICE")?;
6369            remaining &= !Self::METAL_DEVICE.0;
6370            first = false;
6371        }
6372        if remaining & Self::METAL_COMMAND_QUEUE.0 != 0 {
6373            if !first {
6374                f.write_str(" | ")?;
6375            }
6376            f.write_str("METAL_COMMAND_QUEUE")?;
6377            remaining &= !Self::METAL_COMMAND_QUEUE.0;
6378            first = false;
6379        }
6380        if remaining & Self::METAL_BUFFER.0 != 0 {
6381            if !first {
6382                f.write_str(" | ")?;
6383            }
6384            f.write_str("METAL_BUFFER")?;
6385            remaining &= !Self::METAL_BUFFER.0;
6386            first = false;
6387        }
6388        if remaining & Self::METAL_TEXTURE.0 != 0 {
6389            if !first {
6390                f.write_str(" | ")?;
6391            }
6392            f.write_str("METAL_TEXTURE")?;
6393            remaining &= !Self::METAL_TEXTURE.0;
6394            first = false;
6395        }
6396        if remaining & Self::METAL_IOSURFACE.0 != 0 {
6397            if !first {
6398                f.write_str(" | ")?;
6399            }
6400            f.write_str("METAL_IOSURFACE")?;
6401            remaining &= !Self::METAL_IOSURFACE.0;
6402            first = false;
6403        }
6404        if remaining & Self::METAL_SHARED_EVENT.0 != 0 {
6405            if !first {
6406                f.write_str(" | ")?;
6407            }
6408            f.write_str("METAL_SHARED_EVENT")?;
6409            remaining &= !Self::METAL_SHARED_EVENT.0;
6410            first = false;
6411        }
6412        if remaining != 0u32 {
6413            if !first {
6414                f.write_str(" | ")?;
6415            }
6416            write!(f, "{:#x}", remaining)?;
6417        } else if first {
6418            f.write_str("(empty)")?;
6419        }
6420        Ok(())
6421    }
6422}
6423///[`VkExternalFenceFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceFeatureFlagBits.html)
6424#[repr(transparent)]
6425#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
6426#[doc(alias = "VkExternalFenceFeatureFlagBits")]
6427pub struct ExternalFenceFeatureFlagBits(u32);
6428impl ExternalFenceFeatureFlagBits {
6429    #[inline]
6430    pub const fn empty() -> Self {
6431        Self(0u32)
6432    }
6433    #[inline]
6434    pub const fn from_raw(value: u32) -> Self {
6435        Self(value)
6436    }
6437    #[inline]
6438    pub const fn as_raw(self) -> u32 {
6439        self.0
6440    }
6441    #[inline]
6442    pub const fn is_empty(self) -> bool {
6443        self.0 == 0u32
6444    }
6445    #[inline]
6446    pub const fn contains(self, other: Self) -> bool {
6447        (self.0 & other.0) == other.0
6448    }
6449    ///Bit 0.
6450    pub const EXPORTABLE: Self = Self(1u32);
6451    ///Bit 1.
6452    pub const IMPORTABLE: Self = Self(2u32);
6453}
6454impl core::ops::BitOr for ExternalFenceFeatureFlagBits {
6455    type Output = Self;
6456    #[inline]
6457    fn bitor(self, rhs: Self) -> Self {
6458        Self(self.0 | rhs.0)
6459    }
6460}
6461impl core::ops::BitOrAssign for ExternalFenceFeatureFlagBits {
6462    #[inline]
6463    fn bitor_assign(&mut self, rhs: Self) {
6464        self.0 |= rhs.0;
6465    }
6466}
6467impl core::ops::BitAnd for ExternalFenceFeatureFlagBits {
6468    type Output = Self;
6469    #[inline]
6470    fn bitand(self, rhs: Self) -> Self {
6471        Self(self.0 & rhs.0)
6472    }
6473}
6474impl core::ops::BitAndAssign for ExternalFenceFeatureFlagBits {
6475    #[inline]
6476    fn bitand_assign(&mut self, rhs: Self) {
6477        self.0 &= rhs.0;
6478    }
6479}
6480impl core::ops::BitXor for ExternalFenceFeatureFlagBits {
6481    type Output = Self;
6482    #[inline]
6483    fn bitxor(self, rhs: Self) -> Self {
6484        Self(self.0 ^ rhs.0)
6485    }
6486}
6487impl core::ops::BitXorAssign for ExternalFenceFeatureFlagBits {
6488    #[inline]
6489    fn bitxor_assign(&mut self, rhs: Self) {
6490        self.0 ^= rhs.0;
6491    }
6492}
6493impl core::ops::Not for ExternalFenceFeatureFlagBits {
6494    type Output = Self;
6495    #[inline]
6496    fn not(self) -> Self {
6497        Self(!self.0)
6498    }
6499}
6500impl core::fmt::Debug for ExternalFenceFeatureFlagBits {
6501    #[allow(unused_mut, unused_variables)]
6502    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6503        let mut first = true;
6504        let mut remaining = self.0;
6505        if remaining & Self::EXPORTABLE.0 != 0 {
6506            if !first {
6507                f.write_str(" | ")?;
6508            }
6509            f.write_str("EXPORTABLE")?;
6510            remaining &= !Self::EXPORTABLE.0;
6511            first = false;
6512        }
6513        if remaining & Self::IMPORTABLE.0 != 0 {
6514            if !first {
6515                f.write_str(" | ")?;
6516            }
6517            f.write_str("IMPORTABLE")?;
6518            remaining &= !Self::IMPORTABLE.0;
6519            first = false;
6520        }
6521        if remaining != 0u32 {
6522            if !first {
6523                f.write_str(" | ")?;
6524            }
6525            write!(f, "{:#x}", remaining)?;
6526        } else if first {
6527            f.write_str("(empty)")?;
6528        }
6529        Ok(())
6530    }
6531}
6532///[`VkExternalFenceHandleTypeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceHandleTypeFlagBits.html)
6533#[repr(transparent)]
6534#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
6535#[doc(alias = "VkExternalFenceHandleTypeFlagBits")]
6536pub struct ExternalFenceHandleTypeFlagBits(u32);
6537impl ExternalFenceHandleTypeFlagBits {
6538    #[inline]
6539    pub const fn empty() -> Self {
6540        Self(0u32)
6541    }
6542    #[inline]
6543    pub const fn from_raw(value: u32) -> Self {
6544        Self(value)
6545    }
6546    #[inline]
6547    pub const fn as_raw(self) -> u32 {
6548        self.0
6549    }
6550    #[inline]
6551    pub const fn is_empty(self) -> bool {
6552        self.0 == 0u32
6553    }
6554    #[inline]
6555    pub const fn contains(self, other: Self) -> bool {
6556        (self.0 & other.0) == other.0
6557    }
6558    ///Bit 0.
6559    pub const OPAQUE_FD: Self = Self(1u32);
6560    ///Bit 1.
6561    pub const OPAQUE_WIN32: Self = Self(2u32);
6562    ///Bit 2.
6563    pub const OPAQUE_WIN32_KMT: Self = Self(4u32);
6564    ///Bit 3.
6565    pub const SYNC_FD: Self = Self(8u32);
6566}
6567impl core::ops::BitOr for ExternalFenceHandleTypeFlagBits {
6568    type Output = Self;
6569    #[inline]
6570    fn bitor(self, rhs: Self) -> Self {
6571        Self(self.0 | rhs.0)
6572    }
6573}
6574impl core::ops::BitOrAssign for ExternalFenceHandleTypeFlagBits {
6575    #[inline]
6576    fn bitor_assign(&mut self, rhs: Self) {
6577        self.0 |= rhs.0;
6578    }
6579}
6580impl core::ops::BitAnd for ExternalFenceHandleTypeFlagBits {
6581    type Output = Self;
6582    #[inline]
6583    fn bitand(self, rhs: Self) -> Self {
6584        Self(self.0 & rhs.0)
6585    }
6586}
6587impl core::ops::BitAndAssign for ExternalFenceHandleTypeFlagBits {
6588    #[inline]
6589    fn bitand_assign(&mut self, rhs: Self) {
6590        self.0 &= rhs.0;
6591    }
6592}
6593impl core::ops::BitXor for ExternalFenceHandleTypeFlagBits {
6594    type Output = Self;
6595    #[inline]
6596    fn bitxor(self, rhs: Self) -> Self {
6597        Self(self.0 ^ rhs.0)
6598    }
6599}
6600impl core::ops::BitXorAssign for ExternalFenceHandleTypeFlagBits {
6601    #[inline]
6602    fn bitxor_assign(&mut self, rhs: Self) {
6603        self.0 ^= rhs.0;
6604    }
6605}
6606impl core::ops::Not for ExternalFenceHandleTypeFlagBits {
6607    type Output = Self;
6608    #[inline]
6609    fn not(self) -> Self {
6610        Self(!self.0)
6611    }
6612}
6613impl core::fmt::Debug for ExternalFenceHandleTypeFlagBits {
6614    #[allow(unused_mut, unused_variables)]
6615    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6616        let mut first = true;
6617        let mut remaining = self.0;
6618        if remaining & Self::OPAQUE_FD.0 != 0 {
6619            if !first {
6620                f.write_str(" | ")?;
6621            }
6622            f.write_str("OPAQUE_FD")?;
6623            remaining &= !Self::OPAQUE_FD.0;
6624            first = false;
6625        }
6626        if remaining & Self::OPAQUE_WIN32.0 != 0 {
6627            if !first {
6628                f.write_str(" | ")?;
6629            }
6630            f.write_str("OPAQUE_WIN32")?;
6631            remaining &= !Self::OPAQUE_WIN32.0;
6632            first = false;
6633        }
6634        if remaining & Self::OPAQUE_WIN32_KMT.0 != 0 {
6635            if !first {
6636                f.write_str(" | ")?;
6637            }
6638            f.write_str("OPAQUE_WIN32_KMT")?;
6639            remaining &= !Self::OPAQUE_WIN32_KMT.0;
6640            first = false;
6641        }
6642        if remaining & Self::SYNC_FD.0 != 0 {
6643            if !first {
6644                f.write_str(" | ")?;
6645            }
6646            f.write_str("SYNC_FD")?;
6647            remaining &= !Self::SYNC_FD.0;
6648            first = false;
6649        }
6650        if remaining != 0u32 {
6651            if !first {
6652                f.write_str(" | ")?;
6653            }
6654            write!(f, "{:#x}", remaining)?;
6655        } else if first {
6656            f.write_str("(empty)")?;
6657        }
6658        Ok(())
6659    }
6660}
6661///[`VkExternalMemoryFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagBits.html)
6662#[repr(transparent)]
6663#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
6664#[doc(alias = "VkExternalMemoryFeatureFlagBits")]
6665pub struct ExternalMemoryFeatureFlagBits(u32);
6666impl ExternalMemoryFeatureFlagBits {
6667    #[inline]
6668    pub const fn empty() -> Self {
6669        Self(0u32)
6670    }
6671    #[inline]
6672    pub const fn from_raw(value: u32) -> Self {
6673        Self(value)
6674    }
6675    #[inline]
6676    pub const fn as_raw(self) -> u32 {
6677        self.0
6678    }
6679    #[inline]
6680    pub const fn is_empty(self) -> bool {
6681        self.0 == 0u32
6682    }
6683    #[inline]
6684    pub const fn contains(self, other: Self) -> bool {
6685        (self.0 & other.0) == other.0
6686    }
6687    ///Bit 0.
6688    pub const DEDICATED_ONLY: Self = Self(1u32);
6689    ///Bit 1.
6690    pub const EXPORTABLE: Self = Self(2u32);
6691    ///Bit 2.
6692    pub const IMPORTABLE: Self = Self(4u32);
6693}
6694impl core::ops::BitOr for ExternalMemoryFeatureFlagBits {
6695    type Output = Self;
6696    #[inline]
6697    fn bitor(self, rhs: Self) -> Self {
6698        Self(self.0 | rhs.0)
6699    }
6700}
6701impl core::ops::BitOrAssign for ExternalMemoryFeatureFlagBits {
6702    #[inline]
6703    fn bitor_assign(&mut self, rhs: Self) {
6704        self.0 |= rhs.0;
6705    }
6706}
6707impl core::ops::BitAnd for ExternalMemoryFeatureFlagBits {
6708    type Output = Self;
6709    #[inline]
6710    fn bitand(self, rhs: Self) -> Self {
6711        Self(self.0 & rhs.0)
6712    }
6713}
6714impl core::ops::BitAndAssign for ExternalMemoryFeatureFlagBits {
6715    #[inline]
6716    fn bitand_assign(&mut self, rhs: Self) {
6717        self.0 &= rhs.0;
6718    }
6719}
6720impl core::ops::BitXor for ExternalMemoryFeatureFlagBits {
6721    type Output = Self;
6722    #[inline]
6723    fn bitxor(self, rhs: Self) -> Self {
6724        Self(self.0 ^ rhs.0)
6725    }
6726}
6727impl core::ops::BitXorAssign for ExternalMemoryFeatureFlagBits {
6728    #[inline]
6729    fn bitxor_assign(&mut self, rhs: Self) {
6730        self.0 ^= rhs.0;
6731    }
6732}
6733impl core::ops::Not for ExternalMemoryFeatureFlagBits {
6734    type Output = Self;
6735    #[inline]
6736    fn not(self) -> Self {
6737        Self(!self.0)
6738    }
6739}
6740impl core::fmt::Debug for ExternalMemoryFeatureFlagBits {
6741    #[allow(unused_mut, unused_variables)]
6742    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6743        let mut first = true;
6744        let mut remaining = self.0;
6745        if remaining & Self::DEDICATED_ONLY.0 != 0 {
6746            if !first {
6747                f.write_str(" | ")?;
6748            }
6749            f.write_str("DEDICATED_ONLY")?;
6750            remaining &= !Self::DEDICATED_ONLY.0;
6751            first = false;
6752        }
6753        if remaining & Self::EXPORTABLE.0 != 0 {
6754            if !first {
6755                f.write_str(" | ")?;
6756            }
6757            f.write_str("EXPORTABLE")?;
6758            remaining &= !Self::EXPORTABLE.0;
6759            first = false;
6760        }
6761        if remaining & Self::IMPORTABLE.0 != 0 {
6762            if !first {
6763                f.write_str(" | ")?;
6764            }
6765            f.write_str("IMPORTABLE")?;
6766            remaining &= !Self::IMPORTABLE.0;
6767            first = false;
6768        }
6769        if remaining != 0u32 {
6770            if !first {
6771                f.write_str(" | ")?;
6772            }
6773            write!(f, "{:#x}", remaining)?;
6774        } else if first {
6775            f.write_str("(empty)")?;
6776        }
6777        Ok(())
6778    }
6779}
6780///[`VkExternalMemoryFeatureFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagBitsNV.html)
6781#[repr(transparent)]
6782#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
6783#[doc(alias = "VkExternalMemoryFeatureFlagBitsNV")]
6784pub struct ExternalMemoryFeatureFlagBitsNV(u32);
6785impl ExternalMemoryFeatureFlagBitsNV {
6786    #[inline]
6787    pub const fn empty() -> Self {
6788        Self(0u32)
6789    }
6790    #[inline]
6791    pub const fn from_raw(value: u32) -> Self {
6792        Self(value)
6793    }
6794    #[inline]
6795    pub const fn as_raw(self) -> u32 {
6796        self.0
6797    }
6798    #[inline]
6799    pub const fn is_empty(self) -> bool {
6800        self.0 == 0u32
6801    }
6802    #[inline]
6803    pub const fn contains(self, other: Self) -> bool {
6804        (self.0 & other.0) == other.0
6805    }
6806    ///Bit 0.
6807    pub const DEDICATED_ONLY: Self = Self(1u32);
6808    ///Bit 1.
6809    pub const EXPORTABLE: Self = Self(2u32);
6810    ///Bit 2.
6811    pub const IMPORTABLE: Self = Self(4u32);
6812}
6813impl core::ops::BitOr for ExternalMemoryFeatureFlagBitsNV {
6814    type Output = Self;
6815    #[inline]
6816    fn bitor(self, rhs: Self) -> Self {
6817        Self(self.0 | rhs.0)
6818    }
6819}
6820impl core::ops::BitOrAssign for ExternalMemoryFeatureFlagBitsNV {
6821    #[inline]
6822    fn bitor_assign(&mut self, rhs: Self) {
6823        self.0 |= rhs.0;
6824    }
6825}
6826impl core::ops::BitAnd for ExternalMemoryFeatureFlagBitsNV {
6827    type Output = Self;
6828    #[inline]
6829    fn bitand(self, rhs: Self) -> Self {
6830        Self(self.0 & rhs.0)
6831    }
6832}
6833impl core::ops::BitAndAssign for ExternalMemoryFeatureFlagBitsNV {
6834    #[inline]
6835    fn bitand_assign(&mut self, rhs: Self) {
6836        self.0 &= rhs.0;
6837    }
6838}
6839impl core::ops::BitXor for ExternalMemoryFeatureFlagBitsNV {
6840    type Output = Self;
6841    #[inline]
6842    fn bitxor(self, rhs: Self) -> Self {
6843        Self(self.0 ^ rhs.0)
6844    }
6845}
6846impl core::ops::BitXorAssign for ExternalMemoryFeatureFlagBitsNV {
6847    #[inline]
6848    fn bitxor_assign(&mut self, rhs: Self) {
6849        self.0 ^= rhs.0;
6850    }
6851}
6852impl core::ops::Not for ExternalMemoryFeatureFlagBitsNV {
6853    type Output = Self;
6854    #[inline]
6855    fn not(self) -> Self {
6856        Self(!self.0)
6857    }
6858}
6859impl core::fmt::Debug for ExternalMemoryFeatureFlagBitsNV {
6860    #[allow(unused_mut, unused_variables)]
6861    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6862        let mut first = true;
6863        let mut remaining = self.0;
6864        if remaining & Self::DEDICATED_ONLY.0 != 0 {
6865            if !first {
6866                f.write_str(" | ")?;
6867            }
6868            f.write_str("DEDICATED_ONLY")?;
6869            remaining &= !Self::DEDICATED_ONLY.0;
6870            first = false;
6871        }
6872        if remaining & Self::EXPORTABLE.0 != 0 {
6873            if !first {
6874                f.write_str(" | ")?;
6875            }
6876            f.write_str("EXPORTABLE")?;
6877            remaining &= !Self::EXPORTABLE.0;
6878            first = false;
6879        }
6880        if remaining & Self::IMPORTABLE.0 != 0 {
6881            if !first {
6882                f.write_str(" | ")?;
6883            }
6884            f.write_str("IMPORTABLE")?;
6885            remaining &= !Self::IMPORTABLE.0;
6886            first = false;
6887        }
6888        if remaining != 0u32 {
6889            if !first {
6890                f.write_str(" | ")?;
6891            }
6892            write!(f, "{:#x}", remaining)?;
6893        } else if first {
6894            f.write_str("(empty)")?;
6895        }
6896        Ok(())
6897    }
6898}
6899///[`VkExternalMemoryHandleTypeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagBits.html)
6900#[repr(transparent)]
6901#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
6902#[doc(alias = "VkExternalMemoryHandleTypeFlagBits")]
6903pub struct ExternalMemoryHandleTypeFlagBits(u32);
6904impl ExternalMemoryHandleTypeFlagBits {
6905    #[inline]
6906    pub const fn empty() -> Self {
6907        Self(0u32)
6908    }
6909    #[inline]
6910    pub const fn from_raw(value: u32) -> Self {
6911        Self(value)
6912    }
6913    #[inline]
6914    pub const fn as_raw(self) -> u32 {
6915        self.0
6916    }
6917    #[inline]
6918    pub const fn is_empty(self) -> bool {
6919        self.0 == 0u32
6920    }
6921    #[inline]
6922    pub const fn contains(self, other: Self) -> bool {
6923        (self.0 & other.0) == other.0
6924    }
6925    ///Bit 0.
6926    pub const OPAQUE_FD: Self = Self(1u32);
6927    ///Bit 1.
6928    pub const OPAQUE_WIN32: Self = Self(2u32);
6929    ///Bit 2.
6930    pub const OPAQUE_WIN32_KMT: Self = Self(4u32);
6931    ///Bit 3.
6932    pub const D3D11_TEXTURE: Self = Self(8u32);
6933    ///Bit 4.
6934    pub const D3D11_TEXTURE_KMT: Self = Self(16u32);
6935    ///Bit 5.
6936    pub const D3D12_HEAP: Self = Self(32u32);
6937    ///Bit 6.
6938    pub const D3D12_RESOURCE: Self = Self(64u32);
6939    ///Bit 9.
6940    pub const DMA_BUF: Self = Self(512u32);
6941    ///Bit 10.
6942    pub const ANDROID_HARDWARE_BUFFER_BIT: Self = Self(1024u32);
6943    ///Bit 7.
6944    pub const HOST_ALLOCATION: Self = Self(128u32);
6945    ///Bit 8.
6946    pub const HOST_MAPPED_FOREIGN_MEMORY: Self = Self(256u32);
6947    ///Bit 11.
6948    pub const ZIRCON_VMO_BIT: Self = Self(2048u32);
6949    ///Bit 12.
6950    pub const RDMA_ADDRESS: Self = Self(4096u32);
6951    ///Bit 15.
6952    pub const OH_NATIVE_BUFFER_BIT: Self = Self(32768u32);
6953    ///Bit 14.
6954    pub const SCREEN_BUFFER_BIT: Self = Self(16384u32);
6955    ///Bit 16.
6956    pub const MTLBUFFER: Self = Self(65536u32);
6957    ///Bit 17.
6958    pub const MTLTEXTURE: Self = Self(131072u32);
6959    ///Bit 18.
6960    pub const MTLHEAP: Self = Self(262144u32);
6961}
6962impl core::ops::BitOr for ExternalMemoryHandleTypeFlagBits {
6963    type Output = Self;
6964    #[inline]
6965    fn bitor(self, rhs: Self) -> Self {
6966        Self(self.0 | rhs.0)
6967    }
6968}
6969impl core::ops::BitOrAssign for ExternalMemoryHandleTypeFlagBits {
6970    #[inline]
6971    fn bitor_assign(&mut self, rhs: Self) {
6972        self.0 |= rhs.0;
6973    }
6974}
6975impl core::ops::BitAnd for ExternalMemoryHandleTypeFlagBits {
6976    type Output = Self;
6977    #[inline]
6978    fn bitand(self, rhs: Self) -> Self {
6979        Self(self.0 & rhs.0)
6980    }
6981}
6982impl core::ops::BitAndAssign for ExternalMemoryHandleTypeFlagBits {
6983    #[inline]
6984    fn bitand_assign(&mut self, rhs: Self) {
6985        self.0 &= rhs.0;
6986    }
6987}
6988impl core::ops::BitXor for ExternalMemoryHandleTypeFlagBits {
6989    type Output = Self;
6990    #[inline]
6991    fn bitxor(self, rhs: Self) -> Self {
6992        Self(self.0 ^ rhs.0)
6993    }
6994}
6995impl core::ops::BitXorAssign for ExternalMemoryHandleTypeFlagBits {
6996    #[inline]
6997    fn bitxor_assign(&mut self, rhs: Self) {
6998        self.0 ^= rhs.0;
6999    }
7000}
7001impl core::ops::Not for ExternalMemoryHandleTypeFlagBits {
7002    type Output = Self;
7003    #[inline]
7004    fn not(self) -> Self {
7005        Self(!self.0)
7006    }
7007}
7008impl core::fmt::Debug for ExternalMemoryHandleTypeFlagBits {
7009    #[allow(unused_mut, unused_variables)]
7010    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7011        let mut first = true;
7012        let mut remaining = self.0;
7013        if remaining & Self::OPAQUE_FD.0 != 0 {
7014            if !first {
7015                f.write_str(" | ")?;
7016            }
7017            f.write_str("OPAQUE_FD")?;
7018            remaining &= !Self::OPAQUE_FD.0;
7019            first = false;
7020        }
7021        if remaining & Self::OPAQUE_WIN32.0 != 0 {
7022            if !first {
7023                f.write_str(" | ")?;
7024            }
7025            f.write_str("OPAQUE_WIN32")?;
7026            remaining &= !Self::OPAQUE_WIN32.0;
7027            first = false;
7028        }
7029        if remaining & Self::OPAQUE_WIN32_KMT.0 != 0 {
7030            if !first {
7031                f.write_str(" | ")?;
7032            }
7033            f.write_str("OPAQUE_WIN32_KMT")?;
7034            remaining &= !Self::OPAQUE_WIN32_KMT.0;
7035            first = false;
7036        }
7037        if remaining & Self::D3D11_TEXTURE.0 != 0 {
7038            if !first {
7039                f.write_str(" | ")?;
7040            }
7041            f.write_str("D3D11_TEXTURE")?;
7042            remaining &= !Self::D3D11_TEXTURE.0;
7043            first = false;
7044        }
7045        if remaining & Self::D3D11_TEXTURE_KMT.0 != 0 {
7046            if !first {
7047                f.write_str(" | ")?;
7048            }
7049            f.write_str("D3D11_TEXTURE_KMT")?;
7050            remaining &= !Self::D3D11_TEXTURE_KMT.0;
7051            first = false;
7052        }
7053        if remaining & Self::D3D12_HEAP.0 != 0 {
7054            if !first {
7055                f.write_str(" | ")?;
7056            }
7057            f.write_str("D3D12_HEAP")?;
7058            remaining &= !Self::D3D12_HEAP.0;
7059            first = false;
7060        }
7061        if remaining & Self::D3D12_RESOURCE.0 != 0 {
7062            if !first {
7063                f.write_str(" | ")?;
7064            }
7065            f.write_str("D3D12_RESOURCE")?;
7066            remaining &= !Self::D3D12_RESOURCE.0;
7067            first = false;
7068        }
7069        if remaining & Self::DMA_BUF.0 != 0 {
7070            if !first {
7071                f.write_str(" | ")?;
7072            }
7073            f.write_str("DMA_BUF")?;
7074            remaining &= !Self::DMA_BUF.0;
7075            first = false;
7076        }
7077        if remaining & Self::ANDROID_HARDWARE_BUFFER_BIT.0 != 0 {
7078            if !first {
7079                f.write_str(" | ")?;
7080            }
7081            f.write_str("ANDROID_HARDWARE_BUFFER_BIT")?;
7082            remaining &= !Self::ANDROID_HARDWARE_BUFFER_BIT.0;
7083            first = false;
7084        }
7085        if remaining & Self::HOST_ALLOCATION.0 != 0 {
7086            if !first {
7087                f.write_str(" | ")?;
7088            }
7089            f.write_str("HOST_ALLOCATION")?;
7090            remaining &= !Self::HOST_ALLOCATION.0;
7091            first = false;
7092        }
7093        if remaining & Self::HOST_MAPPED_FOREIGN_MEMORY.0 != 0 {
7094            if !first {
7095                f.write_str(" | ")?;
7096            }
7097            f.write_str("HOST_MAPPED_FOREIGN_MEMORY")?;
7098            remaining &= !Self::HOST_MAPPED_FOREIGN_MEMORY.0;
7099            first = false;
7100        }
7101        if remaining & Self::ZIRCON_VMO_BIT.0 != 0 {
7102            if !first {
7103                f.write_str(" | ")?;
7104            }
7105            f.write_str("ZIRCON_VMO_BIT")?;
7106            remaining &= !Self::ZIRCON_VMO_BIT.0;
7107            first = false;
7108        }
7109        if remaining & Self::RDMA_ADDRESS.0 != 0 {
7110            if !first {
7111                f.write_str(" | ")?;
7112            }
7113            f.write_str("RDMA_ADDRESS")?;
7114            remaining &= !Self::RDMA_ADDRESS.0;
7115            first = false;
7116        }
7117        if remaining & Self::OH_NATIVE_BUFFER_BIT.0 != 0 {
7118            if !first {
7119                f.write_str(" | ")?;
7120            }
7121            f.write_str("OH_NATIVE_BUFFER_BIT")?;
7122            remaining &= !Self::OH_NATIVE_BUFFER_BIT.0;
7123            first = false;
7124        }
7125        if remaining & Self::SCREEN_BUFFER_BIT.0 != 0 {
7126            if !first {
7127                f.write_str(" | ")?;
7128            }
7129            f.write_str("SCREEN_BUFFER_BIT")?;
7130            remaining &= !Self::SCREEN_BUFFER_BIT.0;
7131            first = false;
7132        }
7133        if remaining & Self::MTLBUFFER.0 != 0 {
7134            if !first {
7135                f.write_str(" | ")?;
7136            }
7137            f.write_str("MTLBUFFER")?;
7138            remaining &= !Self::MTLBUFFER.0;
7139            first = false;
7140        }
7141        if remaining & Self::MTLTEXTURE.0 != 0 {
7142            if !first {
7143                f.write_str(" | ")?;
7144            }
7145            f.write_str("MTLTEXTURE")?;
7146            remaining &= !Self::MTLTEXTURE.0;
7147            first = false;
7148        }
7149        if remaining & Self::MTLHEAP.0 != 0 {
7150            if !first {
7151                f.write_str(" | ")?;
7152            }
7153            f.write_str("MTLHEAP")?;
7154            remaining &= !Self::MTLHEAP.0;
7155            first = false;
7156        }
7157        if remaining != 0u32 {
7158            if !first {
7159                f.write_str(" | ")?;
7160            }
7161            write!(f, "{:#x}", remaining)?;
7162        } else if first {
7163            f.write_str("(empty)")?;
7164        }
7165        Ok(())
7166    }
7167}
7168///[`VkExternalMemoryHandleTypeFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html)
7169#[repr(transparent)]
7170#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
7171#[doc(alias = "VkExternalMemoryHandleTypeFlagBitsNV")]
7172pub struct ExternalMemoryHandleTypeFlagBitsNV(u32);
7173impl ExternalMemoryHandleTypeFlagBitsNV {
7174    #[inline]
7175    pub const fn empty() -> Self {
7176        Self(0u32)
7177    }
7178    #[inline]
7179    pub const fn from_raw(value: u32) -> Self {
7180        Self(value)
7181    }
7182    #[inline]
7183    pub const fn as_raw(self) -> u32 {
7184        self.0
7185    }
7186    #[inline]
7187    pub const fn is_empty(self) -> bool {
7188        self.0 == 0u32
7189    }
7190    #[inline]
7191    pub const fn contains(self, other: Self) -> bool {
7192        (self.0 & other.0) == other.0
7193    }
7194    ///Bit 0.
7195    pub const OPAQUE_WIN32: Self = Self(1u32);
7196    ///Bit 1.
7197    pub const OPAQUE_WIN32_KMT: Self = Self(2u32);
7198    ///Bit 2.
7199    pub const D3D11_IMAGE: Self = Self(4u32);
7200    ///Bit 3.
7201    pub const D3D11_IMAGE_KMT: Self = Self(8u32);
7202}
7203impl core::ops::BitOr for ExternalMemoryHandleTypeFlagBitsNV {
7204    type Output = Self;
7205    #[inline]
7206    fn bitor(self, rhs: Self) -> Self {
7207        Self(self.0 | rhs.0)
7208    }
7209}
7210impl core::ops::BitOrAssign for ExternalMemoryHandleTypeFlagBitsNV {
7211    #[inline]
7212    fn bitor_assign(&mut self, rhs: Self) {
7213        self.0 |= rhs.0;
7214    }
7215}
7216impl core::ops::BitAnd for ExternalMemoryHandleTypeFlagBitsNV {
7217    type Output = Self;
7218    #[inline]
7219    fn bitand(self, rhs: Self) -> Self {
7220        Self(self.0 & rhs.0)
7221    }
7222}
7223impl core::ops::BitAndAssign for ExternalMemoryHandleTypeFlagBitsNV {
7224    #[inline]
7225    fn bitand_assign(&mut self, rhs: Self) {
7226        self.0 &= rhs.0;
7227    }
7228}
7229impl core::ops::BitXor for ExternalMemoryHandleTypeFlagBitsNV {
7230    type Output = Self;
7231    #[inline]
7232    fn bitxor(self, rhs: Self) -> Self {
7233        Self(self.0 ^ rhs.0)
7234    }
7235}
7236impl core::ops::BitXorAssign for ExternalMemoryHandleTypeFlagBitsNV {
7237    #[inline]
7238    fn bitxor_assign(&mut self, rhs: Self) {
7239        self.0 ^= rhs.0;
7240    }
7241}
7242impl core::ops::Not for ExternalMemoryHandleTypeFlagBitsNV {
7243    type Output = Self;
7244    #[inline]
7245    fn not(self) -> Self {
7246        Self(!self.0)
7247    }
7248}
7249impl core::fmt::Debug for ExternalMemoryHandleTypeFlagBitsNV {
7250    #[allow(unused_mut, unused_variables)]
7251    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7252        let mut first = true;
7253        let mut remaining = self.0;
7254        if remaining & Self::OPAQUE_WIN32.0 != 0 {
7255            if !first {
7256                f.write_str(" | ")?;
7257            }
7258            f.write_str("OPAQUE_WIN32")?;
7259            remaining &= !Self::OPAQUE_WIN32.0;
7260            first = false;
7261        }
7262        if remaining & Self::OPAQUE_WIN32_KMT.0 != 0 {
7263            if !first {
7264                f.write_str(" | ")?;
7265            }
7266            f.write_str("OPAQUE_WIN32_KMT")?;
7267            remaining &= !Self::OPAQUE_WIN32_KMT.0;
7268            first = false;
7269        }
7270        if remaining & Self::D3D11_IMAGE.0 != 0 {
7271            if !first {
7272                f.write_str(" | ")?;
7273            }
7274            f.write_str("D3D11_IMAGE")?;
7275            remaining &= !Self::D3D11_IMAGE.0;
7276            first = false;
7277        }
7278        if remaining & Self::D3D11_IMAGE_KMT.0 != 0 {
7279            if !first {
7280                f.write_str(" | ")?;
7281            }
7282            f.write_str("D3D11_IMAGE_KMT")?;
7283            remaining &= !Self::D3D11_IMAGE_KMT.0;
7284            first = false;
7285        }
7286        if remaining != 0u32 {
7287            if !first {
7288                f.write_str(" | ")?;
7289            }
7290            write!(f, "{:#x}", remaining)?;
7291        } else if first {
7292            f.write_str("(empty)")?;
7293        }
7294        Ok(())
7295    }
7296}
7297///[`VkExternalSemaphoreFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreFeatureFlagBits.html)
7298#[repr(transparent)]
7299#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
7300#[doc(alias = "VkExternalSemaphoreFeatureFlagBits")]
7301pub struct ExternalSemaphoreFeatureFlagBits(u32);
7302impl ExternalSemaphoreFeatureFlagBits {
7303    #[inline]
7304    pub const fn empty() -> Self {
7305        Self(0u32)
7306    }
7307    #[inline]
7308    pub const fn from_raw(value: u32) -> Self {
7309        Self(value)
7310    }
7311    #[inline]
7312    pub const fn as_raw(self) -> u32 {
7313        self.0
7314    }
7315    #[inline]
7316    pub const fn is_empty(self) -> bool {
7317        self.0 == 0u32
7318    }
7319    #[inline]
7320    pub const fn contains(self, other: Self) -> bool {
7321        (self.0 & other.0) == other.0
7322    }
7323    ///Bit 0.
7324    pub const EXPORTABLE: Self = Self(1u32);
7325    ///Bit 1.
7326    pub const IMPORTABLE: Self = Self(2u32);
7327}
7328impl core::ops::BitOr for ExternalSemaphoreFeatureFlagBits {
7329    type Output = Self;
7330    #[inline]
7331    fn bitor(self, rhs: Self) -> Self {
7332        Self(self.0 | rhs.0)
7333    }
7334}
7335impl core::ops::BitOrAssign for ExternalSemaphoreFeatureFlagBits {
7336    #[inline]
7337    fn bitor_assign(&mut self, rhs: Self) {
7338        self.0 |= rhs.0;
7339    }
7340}
7341impl core::ops::BitAnd for ExternalSemaphoreFeatureFlagBits {
7342    type Output = Self;
7343    #[inline]
7344    fn bitand(self, rhs: Self) -> Self {
7345        Self(self.0 & rhs.0)
7346    }
7347}
7348impl core::ops::BitAndAssign for ExternalSemaphoreFeatureFlagBits {
7349    #[inline]
7350    fn bitand_assign(&mut self, rhs: Self) {
7351        self.0 &= rhs.0;
7352    }
7353}
7354impl core::ops::BitXor for ExternalSemaphoreFeatureFlagBits {
7355    type Output = Self;
7356    #[inline]
7357    fn bitxor(self, rhs: Self) -> Self {
7358        Self(self.0 ^ rhs.0)
7359    }
7360}
7361impl core::ops::BitXorAssign for ExternalSemaphoreFeatureFlagBits {
7362    #[inline]
7363    fn bitxor_assign(&mut self, rhs: Self) {
7364        self.0 ^= rhs.0;
7365    }
7366}
7367impl core::ops::Not for ExternalSemaphoreFeatureFlagBits {
7368    type Output = Self;
7369    #[inline]
7370    fn not(self) -> Self {
7371        Self(!self.0)
7372    }
7373}
7374impl core::fmt::Debug for ExternalSemaphoreFeatureFlagBits {
7375    #[allow(unused_mut, unused_variables)]
7376    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7377        let mut first = true;
7378        let mut remaining = self.0;
7379        if remaining & Self::EXPORTABLE.0 != 0 {
7380            if !first {
7381                f.write_str(" | ")?;
7382            }
7383            f.write_str("EXPORTABLE")?;
7384            remaining &= !Self::EXPORTABLE.0;
7385            first = false;
7386        }
7387        if remaining & Self::IMPORTABLE.0 != 0 {
7388            if !first {
7389                f.write_str(" | ")?;
7390            }
7391            f.write_str("IMPORTABLE")?;
7392            remaining &= !Self::IMPORTABLE.0;
7393            first = false;
7394        }
7395        if remaining != 0u32 {
7396            if !first {
7397                f.write_str(" | ")?;
7398            }
7399            write!(f, "{:#x}", remaining)?;
7400        } else if first {
7401            f.write_str("(empty)")?;
7402        }
7403        Ok(())
7404    }
7405}
7406///[`VkExternalSemaphoreHandleTypeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreHandleTypeFlagBits.html)
7407#[repr(transparent)]
7408#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
7409#[doc(alias = "VkExternalSemaphoreHandleTypeFlagBits")]
7410pub struct ExternalSemaphoreHandleTypeFlagBits(u32);
7411impl ExternalSemaphoreHandleTypeFlagBits {
7412    #[inline]
7413    pub const fn empty() -> Self {
7414        Self(0u32)
7415    }
7416    #[inline]
7417    pub const fn from_raw(value: u32) -> Self {
7418        Self(value)
7419    }
7420    #[inline]
7421    pub const fn as_raw(self) -> u32 {
7422        self.0
7423    }
7424    #[inline]
7425    pub const fn is_empty(self) -> bool {
7426        self.0 == 0u32
7427    }
7428    #[inline]
7429    pub const fn contains(self, other: Self) -> bool {
7430        (self.0 & other.0) == other.0
7431    }
7432    ///Bit 0.
7433    pub const OPAQUE_FD: Self = Self(1u32);
7434    ///Bit 1.
7435    pub const OPAQUE_WIN32: Self = Self(2u32);
7436    ///Bit 2.
7437    pub const OPAQUE_WIN32_KMT: Self = Self(4u32);
7438    ///Bit 3.
7439    pub const D3D12_FENCE: Self = Self(8u32);
7440    pub const D3D11_FENCE: Self = Self::D3D12_FENCE;
7441    ///Bit 4.
7442    pub const SYNC_FD: Self = Self(16u32);
7443    ///Bit 7.
7444    pub const ZIRCON_EVENT_BIT: Self = Self(128u32);
7445}
7446impl core::ops::BitOr for ExternalSemaphoreHandleTypeFlagBits {
7447    type Output = Self;
7448    #[inline]
7449    fn bitor(self, rhs: Self) -> Self {
7450        Self(self.0 | rhs.0)
7451    }
7452}
7453impl core::ops::BitOrAssign for ExternalSemaphoreHandleTypeFlagBits {
7454    #[inline]
7455    fn bitor_assign(&mut self, rhs: Self) {
7456        self.0 |= rhs.0;
7457    }
7458}
7459impl core::ops::BitAnd for ExternalSemaphoreHandleTypeFlagBits {
7460    type Output = Self;
7461    #[inline]
7462    fn bitand(self, rhs: Self) -> Self {
7463        Self(self.0 & rhs.0)
7464    }
7465}
7466impl core::ops::BitAndAssign for ExternalSemaphoreHandleTypeFlagBits {
7467    #[inline]
7468    fn bitand_assign(&mut self, rhs: Self) {
7469        self.0 &= rhs.0;
7470    }
7471}
7472impl core::ops::BitXor for ExternalSemaphoreHandleTypeFlagBits {
7473    type Output = Self;
7474    #[inline]
7475    fn bitxor(self, rhs: Self) -> Self {
7476        Self(self.0 ^ rhs.0)
7477    }
7478}
7479impl core::ops::BitXorAssign for ExternalSemaphoreHandleTypeFlagBits {
7480    #[inline]
7481    fn bitxor_assign(&mut self, rhs: Self) {
7482        self.0 ^= rhs.0;
7483    }
7484}
7485impl core::ops::Not for ExternalSemaphoreHandleTypeFlagBits {
7486    type Output = Self;
7487    #[inline]
7488    fn not(self) -> Self {
7489        Self(!self.0)
7490    }
7491}
7492impl core::fmt::Debug for ExternalSemaphoreHandleTypeFlagBits {
7493    #[allow(unused_mut, unused_variables)]
7494    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7495        let mut first = true;
7496        let mut remaining = self.0;
7497        if remaining & Self::OPAQUE_FD.0 != 0 {
7498            if !first {
7499                f.write_str(" | ")?;
7500            }
7501            f.write_str("OPAQUE_FD")?;
7502            remaining &= !Self::OPAQUE_FD.0;
7503            first = false;
7504        }
7505        if remaining & Self::OPAQUE_WIN32.0 != 0 {
7506            if !first {
7507                f.write_str(" | ")?;
7508            }
7509            f.write_str("OPAQUE_WIN32")?;
7510            remaining &= !Self::OPAQUE_WIN32.0;
7511            first = false;
7512        }
7513        if remaining & Self::OPAQUE_WIN32_KMT.0 != 0 {
7514            if !first {
7515                f.write_str(" | ")?;
7516            }
7517            f.write_str("OPAQUE_WIN32_KMT")?;
7518            remaining &= !Self::OPAQUE_WIN32_KMT.0;
7519            first = false;
7520        }
7521        if remaining & Self::D3D12_FENCE.0 != 0 {
7522            if !first {
7523                f.write_str(" | ")?;
7524            }
7525            f.write_str("D3D12_FENCE")?;
7526            remaining &= !Self::D3D12_FENCE.0;
7527            first = false;
7528        }
7529        if remaining & Self::SYNC_FD.0 != 0 {
7530            if !first {
7531                f.write_str(" | ")?;
7532            }
7533            f.write_str("SYNC_FD")?;
7534            remaining &= !Self::SYNC_FD.0;
7535            first = false;
7536        }
7537        if remaining & Self::ZIRCON_EVENT_BIT.0 != 0 {
7538            if !first {
7539                f.write_str(" | ")?;
7540            }
7541            f.write_str("ZIRCON_EVENT_BIT")?;
7542            remaining &= !Self::ZIRCON_EVENT_BIT.0;
7543            first = false;
7544        }
7545        if remaining != 0u32 {
7546            if !first {
7547                f.write_str(" | ")?;
7548            }
7549            write!(f, "{:#x}", remaining)?;
7550        } else if first {
7551            f.write_str("(empty)")?;
7552        }
7553        Ok(())
7554    }
7555}
7556///[`VkFenceCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceCreateFlagBits.html)
7557#[repr(transparent)]
7558#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
7559#[doc(alias = "VkFenceCreateFlagBits")]
7560pub struct FenceCreateFlagBits(u32);
7561impl FenceCreateFlagBits {
7562    #[inline]
7563    pub const fn empty() -> Self {
7564        Self(0u32)
7565    }
7566    #[inline]
7567    pub const fn from_raw(value: u32) -> Self {
7568        Self(value)
7569    }
7570    #[inline]
7571    pub const fn as_raw(self) -> u32 {
7572        self.0
7573    }
7574    #[inline]
7575    pub const fn is_empty(self) -> bool {
7576        self.0 == 0u32
7577    }
7578    #[inline]
7579    pub const fn contains(self, other: Self) -> bool {
7580        (self.0 & other.0) == other.0
7581    }
7582    ///Bit 0.
7583    pub const SIGNALED: Self = Self(1u32);
7584}
7585impl core::ops::BitOr for FenceCreateFlagBits {
7586    type Output = Self;
7587    #[inline]
7588    fn bitor(self, rhs: Self) -> Self {
7589        Self(self.0 | rhs.0)
7590    }
7591}
7592impl core::ops::BitOrAssign for FenceCreateFlagBits {
7593    #[inline]
7594    fn bitor_assign(&mut self, rhs: Self) {
7595        self.0 |= rhs.0;
7596    }
7597}
7598impl core::ops::BitAnd for FenceCreateFlagBits {
7599    type Output = Self;
7600    #[inline]
7601    fn bitand(self, rhs: Self) -> Self {
7602        Self(self.0 & rhs.0)
7603    }
7604}
7605impl core::ops::BitAndAssign for FenceCreateFlagBits {
7606    #[inline]
7607    fn bitand_assign(&mut self, rhs: Self) {
7608        self.0 &= rhs.0;
7609    }
7610}
7611impl core::ops::BitXor for FenceCreateFlagBits {
7612    type Output = Self;
7613    #[inline]
7614    fn bitxor(self, rhs: Self) -> Self {
7615        Self(self.0 ^ rhs.0)
7616    }
7617}
7618impl core::ops::BitXorAssign for FenceCreateFlagBits {
7619    #[inline]
7620    fn bitxor_assign(&mut self, rhs: Self) {
7621        self.0 ^= rhs.0;
7622    }
7623}
7624impl core::ops::Not for FenceCreateFlagBits {
7625    type Output = Self;
7626    #[inline]
7627    fn not(self) -> Self {
7628        Self(!self.0)
7629    }
7630}
7631impl core::fmt::Debug for FenceCreateFlagBits {
7632    #[allow(unused_mut, unused_variables)]
7633    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7634        let mut first = true;
7635        let mut remaining = self.0;
7636        if remaining & Self::SIGNALED.0 != 0 {
7637            if !first {
7638                f.write_str(" | ")?;
7639            }
7640            f.write_str("SIGNALED")?;
7641            remaining &= !Self::SIGNALED.0;
7642            first = false;
7643        }
7644        if remaining != 0u32 {
7645            if !first {
7646                f.write_str(" | ")?;
7647            }
7648            write!(f, "{:#x}", remaining)?;
7649        } else if first {
7650            f.write_str("(empty)")?;
7651        }
7652        Ok(())
7653    }
7654}
7655///[`VkFenceImportFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceImportFlagBits.html)
7656#[repr(transparent)]
7657#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
7658#[doc(alias = "VkFenceImportFlagBits")]
7659pub struct FenceImportFlagBits(u32);
7660impl FenceImportFlagBits {
7661    #[inline]
7662    pub const fn empty() -> Self {
7663        Self(0u32)
7664    }
7665    #[inline]
7666    pub const fn from_raw(value: u32) -> Self {
7667        Self(value)
7668    }
7669    #[inline]
7670    pub const fn as_raw(self) -> u32 {
7671        self.0
7672    }
7673    #[inline]
7674    pub const fn is_empty(self) -> bool {
7675        self.0 == 0u32
7676    }
7677    #[inline]
7678    pub const fn contains(self, other: Self) -> bool {
7679        (self.0 & other.0) == other.0
7680    }
7681    ///Bit 0.
7682    pub const TEMPORARY: Self = Self(1u32);
7683}
7684impl core::ops::BitOr for FenceImportFlagBits {
7685    type Output = Self;
7686    #[inline]
7687    fn bitor(self, rhs: Self) -> Self {
7688        Self(self.0 | rhs.0)
7689    }
7690}
7691impl core::ops::BitOrAssign for FenceImportFlagBits {
7692    #[inline]
7693    fn bitor_assign(&mut self, rhs: Self) {
7694        self.0 |= rhs.0;
7695    }
7696}
7697impl core::ops::BitAnd for FenceImportFlagBits {
7698    type Output = Self;
7699    #[inline]
7700    fn bitand(self, rhs: Self) -> Self {
7701        Self(self.0 & rhs.0)
7702    }
7703}
7704impl core::ops::BitAndAssign for FenceImportFlagBits {
7705    #[inline]
7706    fn bitand_assign(&mut self, rhs: Self) {
7707        self.0 &= rhs.0;
7708    }
7709}
7710impl core::ops::BitXor for FenceImportFlagBits {
7711    type Output = Self;
7712    #[inline]
7713    fn bitxor(self, rhs: Self) -> Self {
7714        Self(self.0 ^ rhs.0)
7715    }
7716}
7717impl core::ops::BitXorAssign for FenceImportFlagBits {
7718    #[inline]
7719    fn bitxor_assign(&mut self, rhs: Self) {
7720        self.0 ^= rhs.0;
7721    }
7722}
7723impl core::ops::Not for FenceImportFlagBits {
7724    type Output = Self;
7725    #[inline]
7726    fn not(self) -> Self {
7727        Self(!self.0)
7728    }
7729}
7730impl core::fmt::Debug for FenceImportFlagBits {
7731    #[allow(unused_mut, unused_variables)]
7732    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7733        let mut first = true;
7734        let mut remaining = self.0;
7735        if remaining & Self::TEMPORARY.0 != 0 {
7736            if !first {
7737                f.write_str(" | ")?;
7738            }
7739            f.write_str("TEMPORARY")?;
7740            remaining &= !Self::TEMPORARY.0;
7741            first = false;
7742        }
7743        if remaining != 0u32 {
7744            if !first {
7745                f.write_str(" | ")?;
7746            }
7747            write!(f, "{:#x}", remaining)?;
7748        } else if first {
7749            f.write_str("(empty)")?;
7750        }
7751        Ok(())
7752    }
7753}
7754///[`VkFormatFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits.html)
7755#[repr(transparent)]
7756#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
7757#[doc(alias = "VkFormatFeatureFlagBits")]
7758pub struct FormatFeatureFlagBits(u32);
7759impl FormatFeatureFlagBits {
7760    #[inline]
7761    pub const fn empty() -> Self {
7762        Self(0u32)
7763    }
7764    #[inline]
7765    pub const fn from_raw(value: u32) -> Self {
7766        Self(value)
7767    }
7768    #[inline]
7769    pub const fn as_raw(self) -> u32 {
7770        self.0
7771    }
7772    #[inline]
7773    pub const fn is_empty(self) -> bool {
7774        self.0 == 0u32
7775    }
7776    #[inline]
7777    pub const fn contains(self, other: Self) -> bool {
7778        (self.0 & other.0) == other.0
7779    }
7780    ///Bit 0.
7781    pub const SAMPLED_IMAGE: Self = Self(1u32);
7782    ///Bit 1.
7783    pub const STORAGE_IMAGE: Self = Self(2u32);
7784    ///Bit 2.
7785    pub const STORAGE_IMAGE_ATOMIC: Self = Self(4u32);
7786    ///Bit 3.
7787    pub const UNIFORM_TEXEL_BUFFER: Self = Self(8u32);
7788    ///Bit 4.
7789    pub const STORAGE_TEXEL_BUFFER: Self = Self(16u32);
7790    ///Bit 5.
7791    pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(32u32);
7792    ///Bit 6.
7793    pub const VERTEX_BUFFER: Self = Self(64u32);
7794    ///Bit 7.
7795    pub const COLOR_ATTACHMENT: Self = Self(128u32);
7796    ///Bit 8.
7797    pub const COLOR_ATTACHMENT_BLEND: Self = Self(256u32);
7798    ///Bit 9.
7799    pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(512u32);
7800    ///Bit 10.
7801    pub const BLIT_SRC: Self = Self(1024u32);
7802    ///Bit 11.
7803    pub const BLIT_DST: Self = Self(2048u32);
7804    ///Bit 12.
7805    pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(4096u32);
7806    ///Bit 14.
7807    pub const TRANSFER_SRC: Self = Self(16384u32);
7808    ///Bit 15.
7809    pub const TRANSFER_DST: Self = Self(32768u32);
7810    ///Bit 17.
7811    pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(131072u32);
7812    ///Bit 18.
7813    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(262144u32);
7814    ///Bit 19.
7815    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = Self(
7816        524288u32,
7817    );
7818    ///Bit 20.
7819    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = Self(
7820        1048576u32,
7821    );
7822    ///Bit 21.
7823    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = Self(
7824        2097152u32,
7825    );
7826    ///Bit 22.
7827    pub const DISJOINT: Self = Self(4194304u32);
7828    ///Bit 23.
7829    pub const COSITED_CHROMA_SAMPLES: Self = Self(8388608u32);
7830    ///Bit 16.
7831    pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(65536u32);
7832    pub const SAMPLED_IMAGE_FILTER_CUBIC_BIT: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC;
7833    ///Bit 25.
7834    pub const VIDEO_DECODE_OUTPUT: Self = Self(33554432u32);
7835    ///Bit 26.
7836    pub const VIDEO_DECODE_DPB: Self = Self(67108864u32);
7837    ///Bit 29.
7838    pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER: Self = Self(536870912u32);
7839    ///Bit 13.
7840    pub const SAMPLED_IMAGE_FILTER_CUBIC: Self = Self(8192u32);
7841    ///Bit 24.
7842    pub const FRAGMENT_DENSITY_MAP: Self = Self(16777216u32);
7843    ///Bit 30.
7844    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(1073741824u32);
7845    ///Bit 27.
7846    pub const VIDEO_ENCODE_INPUT: Self = Self(134217728u32);
7847    ///Bit 28.
7848    pub const VIDEO_ENCODE_DPB: Self = Self(268435456u32);
7849}
7850impl core::ops::BitOr for FormatFeatureFlagBits {
7851    type Output = Self;
7852    #[inline]
7853    fn bitor(self, rhs: Self) -> Self {
7854        Self(self.0 | rhs.0)
7855    }
7856}
7857impl core::ops::BitOrAssign for FormatFeatureFlagBits {
7858    #[inline]
7859    fn bitor_assign(&mut self, rhs: Self) {
7860        self.0 |= rhs.0;
7861    }
7862}
7863impl core::ops::BitAnd for FormatFeatureFlagBits {
7864    type Output = Self;
7865    #[inline]
7866    fn bitand(self, rhs: Self) -> Self {
7867        Self(self.0 & rhs.0)
7868    }
7869}
7870impl core::ops::BitAndAssign for FormatFeatureFlagBits {
7871    #[inline]
7872    fn bitand_assign(&mut self, rhs: Self) {
7873        self.0 &= rhs.0;
7874    }
7875}
7876impl core::ops::BitXor for FormatFeatureFlagBits {
7877    type Output = Self;
7878    #[inline]
7879    fn bitxor(self, rhs: Self) -> Self {
7880        Self(self.0 ^ rhs.0)
7881    }
7882}
7883impl core::ops::BitXorAssign for FormatFeatureFlagBits {
7884    #[inline]
7885    fn bitxor_assign(&mut self, rhs: Self) {
7886        self.0 ^= rhs.0;
7887    }
7888}
7889impl core::ops::Not for FormatFeatureFlagBits {
7890    type Output = Self;
7891    #[inline]
7892    fn not(self) -> Self {
7893        Self(!self.0)
7894    }
7895}
7896impl core::fmt::Debug for FormatFeatureFlagBits {
7897    #[allow(unused_mut, unused_variables)]
7898    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7899        let mut first = true;
7900        let mut remaining = self.0;
7901        if remaining & Self::SAMPLED_IMAGE.0 != 0 {
7902            if !first {
7903                f.write_str(" | ")?;
7904            }
7905            f.write_str("SAMPLED_IMAGE")?;
7906            remaining &= !Self::SAMPLED_IMAGE.0;
7907            first = false;
7908        }
7909        if remaining & Self::STORAGE_IMAGE.0 != 0 {
7910            if !first {
7911                f.write_str(" | ")?;
7912            }
7913            f.write_str("STORAGE_IMAGE")?;
7914            remaining &= !Self::STORAGE_IMAGE.0;
7915            first = false;
7916        }
7917        if remaining & Self::STORAGE_IMAGE_ATOMIC.0 != 0 {
7918            if !first {
7919                f.write_str(" | ")?;
7920            }
7921            f.write_str("STORAGE_IMAGE_ATOMIC")?;
7922            remaining &= !Self::STORAGE_IMAGE_ATOMIC.0;
7923            first = false;
7924        }
7925        if remaining & Self::UNIFORM_TEXEL_BUFFER.0 != 0 {
7926            if !first {
7927                f.write_str(" | ")?;
7928            }
7929            f.write_str("UNIFORM_TEXEL_BUFFER")?;
7930            remaining &= !Self::UNIFORM_TEXEL_BUFFER.0;
7931            first = false;
7932        }
7933        if remaining & Self::STORAGE_TEXEL_BUFFER.0 != 0 {
7934            if !first {
7935                f.write_str(" | ")?;
7936            }
7937            f.write_str("STORAGE_TEXEL_BUFFER")?;
7938            remaining &= !Self::STORAGE_TEXEL_BUFFER.0;
7939            first = false;
7940        }
7941        if remaining & Self::STORAGE_TEXEL_BUFFER_ATOMIC.0 != 0 {
7942            if !first {
7943                f.write_str(" | ")?;
7944            }
7945            f.write_str("STORAGE_TEXEL_BUFFER_ATOMIC")?;
7946            remaining &= !Self::STORAGE_TEXEL_BUFFER_ATOMIC.0;
7947            first = false;
7948        }
7949        if remaining & Self::VERTEX_BUFFER.0 != 0 {
7950            if !first {
7951                f.write_str(" | ")?;
7952            }
7953            f.write_str("VERTEX_BUFFER")?;
7954            remaining &= !Self::VERTEX_BUFFER.0;
7955            first = false;
7956        }
7957        if remaining & Self::COLOR_ATTACHMENT.0 != 0 {
7958            if !first {
7959                f.write_str(" | ")?;
7960            }
7961            f.write_str("COLOR_ATTACHMENT")?;
7962            remaining &= !Self::COLOR_ATTACHMENT.0;
7963            first = false;
7964        }
7965        if remaining & Self::COLOR_ATTACHMENT_BLEND.0 != 0 {
7966            if !first {
7967                f.write_str(" | ")?;
7968            }
7969            f.write_str("COLOR_ATTACHMENT_BLEND")?;
7970            remaining &= !Self::COLOR_ATTACHMENT_BLEND.0;
7971            first = false;
7972        }
7973        if remaining & Self::DEPTH_STENCIL_ATTACHMENT.0 != 0 {
7974            if !first {
7975                f.write_str(" | ")?;
7976            }
7977            f.write_str("DEPTH_STENCIL_ATTACHMENT")?;
7978            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT.0;
7979            first = false;
7980        }
7981        if remaining & Self::BLIT_SRC.0 != 0 {
7982            if !first {
7983                f.write_str(" | ")?;
7984            }
7985            f.write_str("BLIT_SRC")?;
7986            remaining &= !Self::BLIT_SRC.0;
7987            first = false;
7988        }
7989        if remaining & Self::BLIT_DST.0 != 0 {
7990            if !first {
7991                f.write_str(" | ")?;
7992            }
7993            f.write_str("BLIT_DST")?;
7994            remaining &= !Self::BLIT_DST.0;
7995            first = false;
7996        }
7997        if remaining & Self::SAMPLED_IMAGE_FILTER_LINEAR.0 != 0 {
7998            if !first {
7999                f.write_str(" | ")?;
8000            }
8001            f.write_str("SAMPLED_IMAGE_FILTER_LINEAR")?;
8002            remaining &= !Self::SAMPLED_IMAGE_FILTER_LINEAR.0;
8003            first = false;
8004        }
8005        if remaining & Self::TRANSFER_SRC.0 != 0 {
8006            if !first {
8007                f.write_str(" | ")?;
8008            }
8009            f.write_str("TRANSFER_SRC")?;
8010            remaining &= !Self::TRANSFER_SRC.0;
8011            first = false;
8012        }
8013        if remaining & Self::TRANSFER_DST.0 != 0 {
8014            if !first {
8015                f.write_str(" | ")?;
8016            }
8017            f.write_str("TRANSFER_DST")?;
8018            remaining &= !Self::TRANSFER_DST.0;
8019            first = false;
8020        }
8021        if remaining & Self::MIDPOINT_CHROMA_SAMPLES.0 != 0 {
8022            if !first {
8023                f.write_str(" | ")?;
8024            }
8025            f.write_str("MIDPOINT_CHROMA_SAMPLES")?;
8026            remaining &= !Self::MIDPOINT_CHROMA_SAMPLES.0;
8027            first = false;
8028        }
8029        if remaining & Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0 != 0 {
8030            if !first {
8031                f.write_str(" | ")?;
8032            }
8033            f.write_str("SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER")?;
8034            remaining &= !Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0;
8035            first = false;
8036        }
8037        if remaining
8038            & Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER.0 != 0
8039        {
8040            if !first {
8041                f.write_str(" | ")?;
8042            }
8043            f.write_str(
8044                "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER",
8045            )?;
8046            remaining
8047                &= !Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER
8048                    .0;
8049            first = false;
8050        }
8051        if remaining
8052            & Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT.0 != 0
8053        {
8054            if !first {
8055                f.write_str(" | ")?;
8056            }
8057            f.write_str(
8058                "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT",
8059            )?;
8060            remaining
8061                &= !Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT
8062                    .0;
8063            first = false;
8064        }
8065        if remaining
8066            & Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
8067                .0 != 0
8068        {
8069            if !first {
8070                f.write_str(" | ")?;
8071            }
8072            f.write_str(
8073                "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE",
8074            )?;
8075            remaining
8076                &= !Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
8077                    .0;
8078            first = false;
8079        }
8080        if remaining & Self::DISJOINT.0 != 0 {
8081            if !first {
8082                f.write_str(" | ")?;
8083            }
8084            f.write_str("DISJOINT")?;
8085            remaining &= !Self::DISJOINT.0;
8086            first = false;
8087        }
8088        if remaining & Self::COSITED_CHROMA_SAMPLES.0 != 0 {
8089            if !first {
8090                f.write_str(" | ")?;
8091            }
8092            f.write_str("COSITED_CHROMA_SAMPLES")?;
8093            remaining &= !Self::COSITED_CHROMA_SAMPLES.0;
8094            first = false;
8095        }
8096        if remaining & Self::SAMPLED_IMAGE_FILTER_MINMAX.0 != 0 {
8097            if !first {
8098                f.write_str(" | ")?;
8099            }
8100            f.write_str("SAMPLED_IMAGE_FILTER_MINMAX")?;
8101            remaining &= !Self::SAMPLED_IMAGE_FILTER_MINMAX.0;
8102            first = false;
8103        }
8104        if remaining & Self::VIDEO_DECODE_OUTPUT.0 != 0 {
8105            if !first {
8106                f.write_str(" | ")?;
8107            }
8108            f.write_str("VIDEO_DECODE_OUTPUT")?;
8109            remaining &= !Self::VIDEO_DECODE_OUTPUT.0;
8110            first = false;
8111        }
8112        if remaining & Self::VIDEO_DECODE_DPB.0 != 0 {
8113            if !first {
8114                f.write_str(" | ")?;
8115            }
8116            f.write_str("VIDEO_DECODE_DPB")?;
8117            remaining &= !Self::VIDEO_DECODE_DPB.0;
8118            first = false;
8119        }
8120        if remaining & Self::ACCELERATION_STRUCTURE_VERTEX_BUFFER.0 != 0 {
8121            if !first {
8122                f.write_str(" | ")?;
8123            }
8124            f.write_str("ACCELERATION_STRUCTURE_VERTEX_BUFFER")?;
8125            remaining &= !Self::ACCELERATION_STRUCTURE_VERTEX_BUFFER.0;
8126            first = false;
8127        }
8128        if remaining & Self::SAMPLED_IMAGE_FILTER_CUBIC.0 != 0 {
8129            if !first {
8130                f.write_str(" | ")?;
8131            }
8132            f.write_str("SAMPLED_IMAGE_FILTER_CUBIC")?;
8133            remaining &= !Self::SAMPLED_IMAGE_FILTER_CUBIC.0;
8134            first = false;
8135        }
8136        if remaining & Self::FRAGMENT_DENSITY_MAP.0 != 0 {
8137            if !first {
8138                f.write_str(" | ")?;
8139            }
8140            f.write_str("FRAGMENT_DENSITY_MAP")?;
8141            remaining &= !Self::FRAGMENT_DENSITY_MAP.0;
8142            first = false;
8143        }
8144        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
8145            if !first {
8146                f.write_str(" | ")?;
8147            }
8148            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT")?;
8149            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0;
8150            first = false;
8151        }
8152        if remaining & Self::VIDEO_ENCODE_INPUT.0 != 0 {
8153            if !first {
8154                f.write_str(" | ")?;
8155            }
8156            f.write_str("VIDEO_ENCODE_INPUT")?;
8157            remaining &= !Self::VIDEO_ENCODE_INPUT.0;
8158            first = false;
8159        }
8160        if remaining & Self::VIDEO_ENCODE_DPB.0 != 0 {
8161            if !first {
8162                f.write_str(" | ")?;
8163            }
8164            f.write_str("VIDEO_ENCODE_DPB")?;
8165            remaining &= !Self::VIDEO_ENCODE_DPB.0;
8166            first = false;
8167        }
8168        if remaining != 0u32 {
8169            if !first {
8170                f.write_str(" | ")?;
8171            }
8172            write!(f, "{:#x}", remaining)?;
8173        } else if first {
8174            f.write_str("(empty)")?;
8175        }
8176        Ok(())
8177    }
8178}
8179///[`VkFormatFeatureFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits2.html)
8180#[repr(transparent)]
8181#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
8182#[doc(alias = "VkFormatFeatureFlagBits2")]
8183pub struct FormatFeatureFlagBits2(u64);
8184impl FormatFeatureFlagBits2 {
8185    #[inline]
8186    pub const fn empty() -> Self {
8187        Self(0u64)
8188    }
8189    #[inline]
8190    pub const fn from_raw(value: u64) -> Self {
8191        Self(value)
8192    }
8193    #[inline]
8194    pub const fn as_raw(self) -> u64 {
8195        self.0
8196    }
8197    #[inline]
8198    pub const fn is_empty(self) -> bool {
8199        self.0 == 0u64
8200    }
8201    #[inline]
8202    pub const fn contains(self, other: Self) -> bool {
8203        (self.0 & other.0) == other.0
8204    }
8205    ///Bit 0.
8206    pub const _2_SAMPLED_IMAGE: Self = Self(1u64);
8207    ///Bit 1.
8208    pub const _2_STORAGE_IMAGE: Self = Self(2u64);
8209    ///Bit 2.
8210    pub const _2_STORAGE_IMAGE_ATOMIC: Self = Self(4u64);
8211    ///Bit 3.
8212    pub const _2_UNIFORM_TEXEL_BUFFER: Self = Self(8u64);
8213    ///Bit 4.
8214    pub const _2_STORAGE_TEXEL_BUFFER: Self = Self(16u64);
8215    ///Bit 5.
8216    pub const _2_STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(32u64);
8217    ///Bit 6.
8218    pub const _2_VERTEX_BUFFER: Self = Self(64u64);
8219    ///Bit 7.
8220    pub const _2_COLOR_ATTACHMENT: Self = Self(128u64);
8221    ///Bit 8.
8222    pub const _2_COLOR_ATTACHMENT_BLEND: Self = Self(256u64);
8223    ///Bit 9.
8224    pub const _2_DEPTH_STENCIL_ATTACHMENT: Self = Self(512u64);
8225    ///Bit 10.
8226    pub const _2_BLIT_SRC: Self = Self(1024u64);
8227    ///Bit 11.
8228    pub const _2_BLIT_DST: Self = Self(2048u64);
8229    ///Bit 12.
8230    pub const _2_SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(4096u64);
8231    ///Bit 14.
8232    pub const _2_TRANSFER_SRC: Self = Self(16384u64);
8233    ///Bit 15.
8234    pub const _2_TRANSFER_DST: Self = Self(32768u64);
8235    ///Bit 16.
8236    pub const _2_SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(65536u64);
8237    ///Bit 17.
8238    pub const _2_MIDPOINT_CHROMA_SAMPLES: Self = Self(131072u64);
8239    ///Bit 18.
8240    pub const _2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(262144u64);
8241    ///Bit 19.
8242    pub const _2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = Self(
8243        524288u64,
8244    );
8245    ///Bit 20.
8246    pub const _2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = Self(
8247        1048576u64,
8248    );
8249    ///Bit 21.
8250    pub const _2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = Self(
8251        2097152u64,
8252    );
8253    ///Bit 22.
8254    pub const _2_DISJOINT: Self = Self(4194304u64);
8255    ///Bit 23.
8256    pub const _2_COSITED_CHROMA_SAMPLES: Self = Self(8388608u64);
8257    ///Bit 31.
8258    pub const _2_STORAGE_READ_WITHOUT_FORMAT: Self = Self(2147483648u64);
8259    ///Bit 32.
8260    pub const _2_STORAGE_WRITE_WITHOUT_FORMAT: Self = Self(4294967296u64);
8261    ///Bit 33.
8262    pub const _2_SAMPLED_IMAGE_DEPTH_COMPARISON: Self = Self(8589934592u64);
8263    ///Bit 13.
8264    pub const _2_SAMPLED_IMAGE_FILTER_CUBIC: Self = Self(8192u64);
8265    ///Bit 46.
8266    pub const _2_HOST_IMAGE_TRANSFER: Self = Self(70368744177664u64);
8267    ///Bit 25.
8268    pub const _2_VIDEO_DECODE_OUTPUT: Self = Self(33554432u64);
8269    ///Bit 26.
8270    pub const _2_VIDEO_DECODE_DPB: Self = Self(67108864u64);
8271    ///Bit 29.
8272    pub const _2_ACCELERATION_STRUCTURE_VERTEX_BUFFER: Self = Self(536870912u64);
8273    ///Bit 24.
8274    pub const _2_FRAGMENT_DENSITY_MAP: Self = Self(16777216u64);
8275    ///Bit 30.
8276    pub const _2_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(1073741824u64);
8277    ///Bit 27.
8278    pub const _2_VIDEO_ENCODE_INPUT: Self = Self(134217728u64);
8279    ///Bit 28.
8280    pub const _2_VIDEO_ENCODE_DPB: Self = Self(268435456u64);
8281    ///Bit 51.
8282    pub const _2_ACCELERATION_STRUCTURE_RADIUS_BUFFER: Self = Self(2251799813685248u64);
8283    ///Bit 38.
8284    pub const _2_LINEAR_COLOR_ATTACHMENT: Self = Self(274877906944u64);
8285    ///Bit 34.
8286    pub const _2_WEIGHT_IMAGE_BIT: Self = Self(17179869184u64);
8287    ///Bit 35.
8288    pub const _2_WEIGHT_SAMPLED_IMAGE_BIT: Self = Self(34359738368u64);
8289    ///Bit 36.
8290    pub const _2_BLOCK_MATCHING_BIT: Self = Self(68719476736u64);
8291    ///Bit 37.
8292    pub const _2_BOX_FILTER_SAMPLED_BIT: Self = Self(137438953472u64);
8293    ///Bit 39.
8294    pub const _2_TENSOR_SHADER_BIT: Self = Self(549755813888u64);
8295    ///Bit 43.
8296    pub const _2_TENSOR_IMAGE_ALIASING_BIT: Self = Self(8796093022208u64);
8297    ///Bit 40.
8298    pub const _2_OPTICAL_FLOW_IMAGE: Self = Self(1099511627776u64);
8299    ///Bit 41.
8300    pub const _2_OPTICAL_FLOW_VECTOR: Self = Self(2199023255552u64);
8301    ///Bit 42.
8302    pub const _2_OPTICAL_FLOW_COST: Self = Self(4398046511104u64);
8303    ///Bit 48.
8304    pub const _2_TENSOR_DATA_GRAPH_BIT: Self = Self(281474976710656u64);
8305    ///Bit 59.
8306    pub const _2_COPY_IMAGE_INDIRECT_DST: Self = Self(576460752303423488u64);
8307    ///Bit 49.
8308    pub const _2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP: Self = Self(562949953421312u64);
8309    ///Bit 50.
8310    pub const _2_VIDEO_ENCODE_EMPHASIS_MAP: Self = Self(1125899906842624u64);
8311    ///Bit 52.
8312    pub const _2_DEPTH_COPY_ON_COMPUTE_QUEUE: Self = Self(4503599627370496u64);
8313    ///Bit 53.
8314    pub const _2_DEPTH_COPY_ON_TRANSFER_QUEUE: Self = Self(9007199254740992u64);
8315    ///Bit 54.
8316    pub const _2_STENCIL_COPY_ON_COMPUTE_QUEUE: Self = Self(18014398509481984u64);
8317    ///Bit 55.
8318    pub const _2_STENCIL_COPY_ON_TRANSFER_QUEUE: Self = Self(36028797018963968u64);
8319}
8320impl core::ops::BitOr for FormatFeatureFlagBits2 {
8321    type Output = Self;
8322    #[inline]
8323    fn bitor(self, rhs: Self) -> Self {
8324        Self(self.0 | rhs.0)
8325    }
8326}
8327impl core::ops::BitOrAssign for FormatFeatureFlagBits2 {
8328    #[inline]
8329    fn bitor_assign(&mut self, rhs: Self) {
8330        self.0 |= rhs.0;
8331    }
8332}
8333impl core::ops::BitAnd for FormatFeatureFlagBits2 {
8334    type Output = Self;
8335    #[inline]
8336    fn bitand(self, rhs: Self) -> Self {
8337        Self(self.0 & rhs.0)
8338    }
8339}
8340impl core::ops::BitAndAssign for FormatFeatureFlagBits2 {
8341    #[inline]
8342    fn bitand_assign(&mut self, rhs: Self) {
8343        self.0 &= rhs.0;
8344    }
8345}
8346impl core::ops::BitXor for FormatFeatureFlagBits2 {
8347    type Output = Self;
8348    #[inline]
8349    fn bitxor(self, rhs: Self) -> Self {
8350        Self(self.0 ^ rhs.0)
8351    }
8352}
8353impl core::ops::BitXorAssign for FormatFeatureFlagBits2 {
8354    #[inline]
8355    fn bitxor_assign(&mut self, rhs: Self) {
8356        self.0 ^= rhs.0;
8357    }
8358}
8359impl core::ops::Not for FormatFeatureFlagBits2 {
8360    type Output = Self;
8361    #[inline]
8362    fn not(self) -> Self {
8363        Self(!self.0)
8364    }
8365}
8366impl core::fmt::Debug for FormatFeatureFlagBits2 {
8367    #[allow(unused_mut, unused_variables)]
8368    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
8369        let mut first = true;
8370        let mut remaining = self.0;
8371        if remaining & Self::_2_SAMPLED_IMAGE.0 != 0 {
8372            if !first {
8373                f.write_str(" | ")?;
8374            }
8375            f.write_str("_2_SAMPLED_IMAGE")?;
8376            remaining &= !Self::_2_SAMPLED_IMAGE.0;
8377            first = false;
8378        }
8379        if remaining & Self::_2_STORAGE_IMAGE.0 != 0 {
8380            if !first {
8381                f.write_str(" | ")?;
8382            }
8383            f.write_str("_2_STORAGE_IMAGE")?;
8384            remaining &= !Self::_2_STORAGE_IMAGE.0;
8385            first = false;
8386        }
8387        if remaining & Self::_2_STORAGE_IMAGE_ATOMIC.0 != 0 {
8388            if !first {
8389                f.write_str(" | ")?;
8390            }
8391            f.write_str("_2_STORAGE_IMAGE_ATOMIC")?;
8392            remaining &= !Self::_2_STORAGE_IMAGE_ATOMIC.0;
8393            first = false;
8394        }
8395        if remaining & Self::_2_UNIFORM_TEXEL_BUFFER.0 != 0 {
8396            if !first {
8397                f.write_str(" | ")?;
8398            }
8399            f.write_str("_2_UNIFORM_TEXEL_BUFFER")?;
8400            remaining &= !Self::_2_UNIFORM_TEXEL_BUFFER.0;
8401            first = false;
8402        }
8403        if remaining & Self::_2_STORAGE_TEXEL_BUFFER.0 != 0 {
8404            if !first {
8405                f.write_str(" | ")?;
8406            }
8407            f.write_str("_2_STORAGE_TEXEL_BUFFER")?;
8408            remaining &= !Self::_2_STORAGE_TEXEL_BUFFER.0;
8409            first = false;
8410        }
8411        if remaining & Self::_2_STORAGE_TEXEL_BUFFER_ATOMIC.0 != 0 {
8412            if !first {
8413                f.write_str(" | ")?;
8414            }
8415            f.write_str("_2_STORAGE_TEXEL_BUFFER_ATOMIC")?;
8416            remaining &= !Self::_2_STORAGE_TEXEL_BUFFER_ATOMIC.0;
8417            first = false;
8418        }
8419        if remaining & Self::_2_VERTEX_BUFFER.0 != 0 {
8420            if !first {
8421                f.write_str(" | ")?;
8422            }
8423            f.write_str("_2_VERTEX_BUFFER")?;
8424            remaining &= !Self::_2_VERTEX_BUFFER.0;
8425            first = false;
8426        }
8427        if remaining & Self::_2_COLOR_ATTACHMENT.0 != 0 {
8428            if !first {
8429                f.write_str(" | ")?;
8430            }
8431            f.write_str("_2_COLOR_ATTACHMENT")?;
8432            remaining &= !Self::_2_COLOR_ATTACHMENT.0;
8433            first = false;
8434        }
8435        if remaining & Self::_2_COLOR_ATTACHMENT_BLEND.0 != 0 {
8436            if !first {
8437                f.write_str(" | ")?;
8438            }
8439            f.write_str("_2_COLOR_ATTACHMENT_BLEND")?;
8440            remaining &= !Self::_2_COLOR_ATTACHMENT_BLEND.0;
8441            first = false;
8442        }
8443        if remaining & Self::_2_DEPTH_STENCIL_ATTACHMENT.0 != 0 {
8444            if !first {
8445                f.write_str(" | ")?;
8446            }
8447            f.write_str("_2_DEPTH_STENCIL_ATTACHMENT")?;
8448            remaining &= !Self::_2_DEPTH_STENCIL_ATTACHMENT.0;
8449            first = false;
8450        }
8451        if remaining & Self::_2_BLIT_SRC.0 != 0 {
8452            if !first {
8453                f.write_str(" | ")?;
8454            }
8455            f.write_str("_2_BLIT_SRC")?;
8456            remaining &= !Self::_2_BLIT_SRC.0;
8457            first = false;
8458        }
8459        if remaining & Self::_2_BLIT_DST.0 != 0 {
8460            if !first {
8461                f.write_str(" | ")?;
8462            }
8463            f.write_str("_2_BLIT_DST")?;
8464            remaining &= !Self::_2_BLIT_DST.0;
8465            first = false;
8466        }
8467        if remaining & Self::_2_SAMPLED_IMAGE_FILTER_LINEAR.0 != 0 {
8468            if !first {
8469                f.write_str(" | ")?;
8470            }
8471            f.write_str("_2_SAMPLED_IMAGE_FILTER_LINEAR")?;
8472            remaining &= !Self::_2_SAMPLED_IMAGE_FILTER_LINEAR.0;
8473            first = false;
8474        }
8475        if remaining & Self::_2_TRANSFER_SRC.0 != 0 {
8476            if !first {
8477                f.write_str(" | ")?;
8478            }
8479            f.write_str("_2_TRANSFER_SRC")?;
8480            remaining &= !Self::_2_TRANSFER_SRC.0;
8481            first = false;
8482        }
8483        if remaining & Self::_2_TRANSFER_DST.0 != 0 {
8484            if !first {
8485                f.write_str(" | ")?;
8486            }
8487            f.write_str("_2_TRANSFER_DST")?;
8488            remaining &= !Self::_2_TRANSFER_DST.0;
8489            first = false;
8490        }
8491        if remaining & Self::_2_SAMPLED_IMAGE_FILTER_MINMAX.0 != 0 {
8492            if !first {
8493                f.write_str(" | ")?;
8494            }
8495            f.write_str("_2_SAMPLED_IMAGE_FILTER_MINMAX")?;
8496            remaining &= !Self::_2_SAMPLED_IMAGE_FILTER_MINMAX.0;
8497            first = false;
8498        }
8499        if remaining & Self::_2_MIDPOINT_CHROMA_SAMPLES.0 != 0 {
8500            if !first {
8501                f.write_str(" | ")?;
8502            }
8503            f.write_str("_2_MIDPOINT_CHROMA_SAMPLES")?;
8504            remaining &= !Self::_2_MIDPOINT_CHROMA_SAMPLES.0;
8505            first = false;
8506        }
8507        if remaining & Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0 != 0 {
8508            if !first {
8509                f.write_str(" | ")?;
8510            }
8511            f.write_str("_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER")?;
8512            remaining &= !Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0;
8513            first = false;
8514        }
8515        if remaining
8516            & Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER.0
8517            != 0
8518        {
8519            if !first {
8520                f.write_str(" | ")?;
8521            }
8522            f.write_str(
8523                "_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER",
8524            )?;
8525            remaining
8526                &= !Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER
8527                    .0;
8528            first = false;
8529        }
8530        if remaining
8531            & Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT.0
8532            != 0
8533        {
8534            if !first {
8535                f.write_str(" | ")?;
8536            }
8537            f.write_str(
8538                "_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT",
8539            )?;
8540            remaining
8541                &= !Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT
8542                    .0;
8543            first = false;
8544        }
8545        if remaining
8546            & Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
8547                .0 != 0
8548        {
8549            if !first {
8550                f.write_str(" | ")?;
8551            }
8552            f.write_str(
8553                "_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE",
8554            )?;
8555            remaining
8556                &= !Self::_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
8557                    .0;
8558            first = false;
8559        }
8560        if remaining & Self::_2_DISJOINT.0 != 0 {
8561            if !first {
8562                f.write_str(" | ")?;
8563            }
8564            f.write_str("_2_DISJOINT")?;
8565            remaining &= !Self::_2_DISJOINT.0;
8566            first = false;
8567        }
8568        if remaining & Self::_2_COSITED_CHROMA_SAMPLES.0 != 0 {
8569            if !first {
8570                f.write_str(" | ")?;
8571            }
8572            f.write_str("_2_COSITED_CHROMA_SAMPLES")?;
8573            remaining &= !Self::_2_COSITED_CHROMA_SAMPLES.0;
8574            first = false;
8575        }
8576        if remaining & Self::_2_STORAGE_READ_WITHOUT_FORMAT.0 != 0 {
8577            if !first {
8578                f.write_str(" | ")?;
8579            }
8580            f.write_str("_2_STORAGE_READ_WITHOUT_FORMAT")?;
8581            remaining &= !Self::_2_STORAGE_READ_WITHOUT_FORMAT.0;
8582            first = false;
8583        }
8584        if remaining & Self::_2_STORAGE_WRITE_WITHOUT_FORMAT.0 != 0 {
8585            if !first {
8586                f.write_str(" | ")?;
8587            }
8588            f.write_str("_2_STORAGE_WRITE_WITHOUT_FORMAT")?;
8589            remaining &= !Self::_2_STORAGE_WRITE_WITHOUT_FORMAT.0;
8590            first = false;
8591        }
8592        if remaining & Self::_2_SAMPLED_IMAGE_DEPTH_COMPARISON.0 != 0 {
8593            if !first {
8594                f.write_str(" | ")?;
8595            }
8596            f.write_str("_2_SAMPLED_IMAGE_DEPTH_COMPARISON")?;
8597            remaining &= !Self::_2_SAMPLED_IMAGE_DEPTH_COMPARISON.0;
8598            first = false;
8599        }
8600        if remaining & Self::_2_SAMPLED_IMAGE_FILTER_CUBIC.0 != 0 {
8601            if !first {
8602                f.write_str(" | ")?;
8603            }
8604            f.write_str("_2_SAMPLED_IMAGE_FILTER_CUBIC")?;
8605            remaining &= !Self::_2_SAMPLED_IMAGE_FILTER_CUBIC.0;
8606            first = false;
8607        }
8608        if remaining & Self::_2_HOST_IMAGE_TRANSFER.0 != 0 {
8609            if !first {
8610                f.write_str(" | ")?;
8611            }
8612            f.write_str("_2_HOST_IMAGE_TRANSFER")?;
8613            remaining &= !Self::_2_HOST_IMAGE_TRANSFER.0;
8614            first = false;
8615        }
8616        if remaining & Self::_2_VIDEO_DECODE_OUTPUT.0 != 0 {
8617            if !first {
8618                f.write_str(" | ")?;
8619            }
8620            f.write_str("_2_VIDEO_DECODE_OUTPUT")?;
8621            remaining &= !Self::_2_VIDEO_DECODE_OUTPUT.0;
8622            first = false;
8623        }
8624        if remaining & Self::_2_VIDEO_DECODE_DPB.0 != 0 {
8625            if !first {
8626                f.write_str(" | ")?;
8627            }
8628            f.write_str("_2_VIDEO_DECODE_DPB")?;
8629            remaining &= !Self::_2_VIDEO_DECODE_DPB.0;
8630            first = false;
8631        }
8632        if remaining & Self::_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER.0 != 0 {
8633            if !first {
8634                f.write_str(" | ")?;
8635            }
8636            f.write_str("_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER")?;
8637            remaining &= !Self::_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER.0;
8638            first = false;
8639        }
8640        if remaining & Self::_2_FRAGMENT_DENSITY_MAP.0 != 0 {
8641            if !first {
8642                f.write_str(" | ")?;
8643            }
8644            f.write_str("_2_FRAGMENT_DENSITY_MAP")?;
8645            remaining &= !Self::_2_FRAGMENT_DENSITY_MAP.0;
8646            first = false;
8647        }
8648        if remaining & Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
8649            if !first {
8650                f.write_str(" | ")?;
8651            }
8652            f.write_str("_2_FRAGMENT_SHADING_RATE_ATTACHMENT")?;
8653            remaining &= !Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT.0;
8654            first = false;
8655        }
8656        if remaining & Self::_2_VIDEO_ENCODE_INPUT.0 != 0 {
8657            if !first {
8658                f.write_str(" | ")?;
8659            }
8660            f.write_str("_2_VIDEO_ENCODE_INPUT")?;
8661            remaining &= !Self::_2_VIDEO_ENCODE_INPUT.0;
8662            first = false;
8663        }
8664        if remaining & Self::_2_VIDEO_ENCODE_DPB.0 != 0 {
8665            if !first {
8666                f.write_str(" | ")?;
8667            }
8668            f.write_str("_2_VIDEO_ENCODE_DPB")?;
8669            remaining &= !Self::_2_VIDEO_ENCODE_DPB.0;
8670            first = false;
8671        }
8672        if remaining & Self::_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER.0 != 0 {
8673            if !first {
8674                f.write_str(" | ")?;
8675            }
8676            f.write_str("_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER")?;
8677            remaining &= !Self::_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER.0;
8678            first = false;
8679        }
8680        if remaining & Self::_2_LINEAR_COLOR_ATTACHMENT.0 != 0 {
8681            if !first {
8682                f.write_str(" | ")?;
8683            }
8684            f.write_str("_2_LINEAR_COLOR_ATTACHMENT")?;
8685            remaining &= !Self::_2_LINEAR_COLOR_ATTACHMENT.0;
8686            first = false;
8687        }
8688        if remaining & Self::_2_WEIGHT_IMAGE_BIT.0 != 0 {
8689            if !first {
8690                f.write_str(" | ")?;
8691            }
8692            f.write_str("_2_WEIGHT_IMAGE_BIT")?;
8693            remaining &= !Self::_2_WEIGHT_IMAGE_BIT.0;
8694            first = false;
8695        }
8696        if remaining & Self::_2_WEIGHT_SAMPLED_IMAGE_BIT.0 != 0 {
8697            if !first {
8698                f.write_str(" | ")?;
8699            }
8700            f.write_str("_2_WEIGHT_SAMPLED_IMAGE_BIT")?;
8701            remaining &= !Self::_2_WEIGHT_SAMPLED_IMAGE_BIT.0;
8702            first = false;
8703        }
8704        if remaining & Self::_2_BLOCK_MATCHING_BIT.0 != 0 {
8705            if !first {
8706                f.write_str(" | ")?;
8707            }
8708            f.write_str("_2_BLOCK_MATCHING_BIT")?;
8709            remaining &= !Self::_2_BLOCK_MATCHING_BIT.0;
8710            first = false;
8711        }
8712        if remaining & Self::_2_BOX_FILTER_SAMPLED_BIT.0 != 0 {
8713            if !first {
8714                f.write_str(" | ")?;
8715            }
8716            f.write_str("_2_BOX_FILTER_SAMPLED_BIT")?;
8717            remaining &= !Self::_2_BOX_FILTER_SAMPLED_BIT.0;
8718            first = false;
8719        }
8720        if remaining & Self::_2_TENSOR_SHADER_BIT.0 != 0 {
8721            if !first {
8722                f.write_str(" | ")?;
8723            }
8724            f.write_str("_2_TENSOR_SHADER_BIT")?;
8725            remaining &= !Self::_2_TENSOR_SHADER_BIT.0;
8726            first = false;
8727        }
8728        if remaining & Self::_2_TENSOR_IMAGE_ALIASING_BIT.0 != 0 {
8729            if !first {
8730                f.write_str(" | ")?;
8731            }
8732            f.write_str("_2_TENSOR_IMAGE_ALIASING_BIT")?;
8733            remaining &= !Self::_2_TENSOR_IMAGE_ALIASING_BIT.0;
8734            first = false;
8735        }
8736        if remaining & Self::_2_OPTICAL_FLOW_IMAGE.0 != 0 {
8737            if !first {
8738                f.write_str(" | ")?;
8739            }
8740            f.write_str("_2_OPTICAL_FLOW_IMAGE")?;
8741            remaining &= !Self::_2_OPTICAL_FLOW_IMAGE.0;
8742            first = false;
8743        }
8744        if remaining & Self::_2_OPTICAL_FLOW_VECTOR.0 != 0 {
8745            if !first {
8746                f.write_str(" | ")?;
8747            }
8748            f.write_str("_2_OPTICAL_FLOW_VECTOR")?;
8749            remaining &= !Self::_2_OPTICAL_FLOW_VECTOR.0;
8750            first = false;
8751        }
8752        if remaining & Self::_2_OPTICAL_FLOW_COST.0 != 0 {
8753            if !first {
8754                f.write_str(" | ")?;
8755            }
8756            f.write_str("_2_OPTICAL_FLOW_COST")?;
8757            remaining &= !Self::_2_OPTICAL_FLOW_COST.0;
8758            first = false;
8759        }
8760        if remaining & Self::_2_TENSOR_DATA_GRAPH_BIT.0 != 0 {
8761            if !first {
8762                f.write_str(" | ")?;
8763            }
8764            f.write_str("_2_TENSOR_DATA_GRAPH_BIT")?;
8765            remaining &= !Self::_2_TENSOR_DATA_GRAPH_BIT.0;
8766            first = false;
8767        }
8768        if remaining & Self::_2_COPY_IMAGE_INDIRECT_DST.0 != 0 {
8769            if !first {
8770                f.write_str(" | ")?;
8771            }
8772            f.write_str("_2_COPY_IMAGE_INDIRECT_DST")?;
8773            remaining &= !Self::_2_COPY_IMAGE_INDIRECT_DST.0;
8774            first = false;
8775        }
8776        if remaining & Self::_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP.0 != 0 {
8777            if !first {
8778                f.write_str(" | ")?;
8779            }
8780            f.write_str("_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP")?;
8781            remaining &= !Self::_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP.0;
8782            first = false;
8783        }
8784        if remaining & Self::_2_VIDEO_ENCODE_EMPHASIS_MAP.0 != 0 {
8785            if !first {
8786                f.write_str(" | ")?;
8787            }
8788            f.write_str("_2_VIDEO_ENCODE_EMPHASIS_MAP")?;
8789            remaining &= !Self::_2_VIDEO_ENCODE_EMPHASIS_MAP.0;
8790            first = false;
8791        }
8792        if remaining & Self::_2_DEPTH_COPY_ON_COMPUTE_QUEUE.0 != 0 {
8793            if !first {
8794                f.write_str(" | ")?;
8795            }
8796            f.write_str("_2_DEPTH_COPY_ON_COMPUTE_QUEUE")?;
8797            remaining &= !Self::_2_DEPTH_COPY_ON_COMPUTE_QUEUE.0;
8798            first = false;
8799        }
8800        if remaining & Self::_2_DEPTH_COPY_ON_TRANSFER_QUEUE.0 != 0 {
8801            if !first {
8802                f.write_str(" | ")?;
8803            }
8804            f.write_str("_2_DEPTH_COPY_ON_TRANSFER_QUEUE")?;
8805            remaining &= !Self::_2_DEPTH_COPY_ON_TRANSFER_QUEUE.0;
8806            first = false;
8807        }
8808        if remaining & Self::_2_STENCIL_COPY_ON_COMPUTE_QUEUE.0 != 0 {
8809            if !first {
8810                f.write_str(" | ")?;
8811            }
8812            f.write_str("_2_STENCIL_COPY_ON_COMPUTE_QUEUE")?;
8813            remaining &= !Self::_2_STENCIL_COPY_ON_COMPUTE_QUEUE.0;
8814            first = false;
8815        }
8816        if remaining & Self::_2_STENCIL_COPY_ON_TRANSFER_QUEUE.0 != 0 {
8817            if !first {
8818                f.write_str(" | ")?;
8819            }
8820            f.write_str("_2_STENCIL_COPY_ON_TRANSFER_QUEUE")?;
8821            remaining &= !Self::_2_STENCIL_COPY_ON_TRANSFER_QUEUE.0;
8822            first = false;
8823        }
8824        if remaining != 0u64 {
8825            if !first {
8826                f.write_str(" | ")?;
8827            }
8828            write!(f, "{:#x}", remaining)?;
8829        } else if first {
8830            f.write_str("(empty)")?;
8831        }
8832        Ok(())
8833    }
8834}
8835///[`VkFrameBoundaryFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryFlagBitsEXT.html)
8836#[repr(transparent)]
8837#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
8838#[doc(alias = "VkFrameBoundaryFlagBitsEXT")]
8839pub struct FrameBoundaryFlagBitsEXT(u32);
8840impl FrameBoundaryFlagBitsEXT {
8841    #[inline]
8842    pub const fn empty() -> Self {
8843        Self(0u32)
8844    }
8845    #[inline]
8846    pub const fn from_raw(value: u32) -> Self {
8847        Self(value)
8848    }
8849    #[inline]
8850    pub const fn as_raw(self) -> u32 {
8851        self.0
8852    }
8853    #[inline]
8854    pub const fn is_empty(self) -> bool {
8855        self.0 == 0u32
8856    }
8857    #[inline]
8858    pub const fn contains(self, other: Self) -> bool {
8859        (self.0 & other.0) == other.0
8860    }
8861    ///Bit 0.
8862    pub const FRAME_END: Self = Self(1u32);
8863}
8864impl core::ops::BitOr for FrameBoundaryFlagBitsEXT {
8865    type Output = Self;
8866    #[inline]
8867    fn bitor(self, rhs: Self) -> Self {
8868        Self(self.0 | rhs.0)
8869    }
8870}
8871impl core::ops::BitOrAssign for FrameBoundaryFlagBitsEXT {
8872    #[inline]
8873    fn bitor_assign(&mut self, rhs: Self) {
8874        self.0 |= rhs.0;
8875    }
8876}
8877impl core::ops::BitAnd for FrameBoundaryFlagBitsEXT {
8878    type Output = Self;
8879    #[inline]
8880    fn bitand(self, rhs: Self) -> Self {
8881        Self(self.0 & rhs.0)
8882    }
8883}
8884impl core::ops::BitAndAssign for FrameBoundaryFlagBitsEXT {
8885    #[inline]
8886    fn bitand_assign(&mut self, rhs: Self) {
8887        self.0 &= rhs.0;
8888    }
8889}
8890impl core::ops::BitXor for FrameBoundaryFlagBitsEXT {
8891    type Output = Self;
8892    #[inline]
8893    fn bitxor(self, rhs: Self) -> Self {
8894        Self(self.0 ^ rhs.0)
8895    }
8896}
8897impl core::ops::BitXorAssign for FrameBoundaryFlagBitsEXT {
8898    #[inline]
8899    fn bitxor_assign(&mut self, rhs: Self) {
8900        self.0 ^= rhs.0;
8901    }
8902}
8903impl core::ops::Not for FrameBoundaryFlagBitsEXT {
8904    type Output = Self;
8905    #[inline]
8906    fn not(self) -> Self {
8907        Self(!self.0)
8908    }
8909}
8910impl core::fmt::Debug for FrameBoundaryFlagBitsEXT {
8911    #[allow(unused_mut, unused_variables)]
8912    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
8913        let mut first = true;
8914        let mut remaining = self.0;
8915        if remaining & Self::FRAME_END.0 != 0 {
8916            if !first {
8917                f.write_str(" | ")?;
8918            }
8919            f.write_str("FRAME_END")?;
8920            remaining &= !Self::FRAME_END.0;
8921            first = false;
8922        }
8923        if remaining != 0u32 {
8924            if !first {
8925                f.write_str(" | ")?;
8926            }
8927            write!(f, "{:#x}", remaining)?;
8928        } else if first {
8929            f.write_str("(empty)")?;
8930        }
8931        Ok(())
8932    }
8933}
8934///[`VkFramebufferCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferCreateFlagBits.html)
8935#[repr(transparent)]
8936#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
8937#[doc(alias = "VkFramebufferCreateFlagBits")]
8938pub struct FramebufferCreateFlagBits(u32);
8939impl FramebufferCreateFlagBits {
8940    #[inline]
8941    pub const fn empty() -> Self {
8942        Self(0u32)
8943    }
8944    #[inline]
8945    pub const fn from_raw(value: u32) -> Self {
8946        Self(value)
8947    }
8948    #[inline]
8949    pub const fn as_raw(self) -> u32 {
8950        self.0
8951    }
8952    #[inline]
8953    pub const fn is_empty(self) -> bool {
8954        self.0 == 0u32
8955    }
8956    #[inline]
8957    pub const fn contains(self, other: Self) -> bool {
8958        (self.0 & other.0) == other.0
8959    }
8960    ///Bit 0.
8961    pub const IMAGELESS: Self = Self(1u32);
8962}
8963impl core::ops::BitOr for FramebufferCreateFlagBits {
8964    type Output = Self;
8965    #[inline]
8966    fn bitor(self, rhs: Self) -> Self {
8967        Self(self.0 | rhs.0)
8968    }
8969}
8970impl core::ops::BitOrAssign for FramebufferCreateFlagBits {
8971    #[inline]
8972    fn bitor_assign(&mut self, rhs: Self) {
8973        self.0 |= rhs.0;
8974    }
8975}
8976impl core::ops::BitAnd for FramebufferCreateFlagBits {
8977    type Output = Self;
8978    #[inline]
8979    fn bitand(self, rhs: Self) -> Self {
8980        Self(self.0 & rhs.0)
8981    }
8982}
8983impl core::ops::BitAndAssign for FramebufferCreateFlagBits {
8984    #[inline]
8985    fn bitand_assign(&mut self, rhs: Self) {
8986        self.0 &= rhs.0;
8987    }
8988}
8989impl core::ops::BitXor for FramebufferCreateFlagBits {
8990    type Output = Self;
8991    #[inline]
8992    fn bitxor(self, rhs: Self) -> Self {
8993        Self(self.0 ^ rhs.0)
8994    }
8995}
8996impl core::ops::BitXorAssign for FramebufferCreateFlagBits {
8997    #[inline]
8998    fn bitxor_assign(&mut self, rhs: Self) {
8999        self.0 ^= rhs.0;
9000    }
9001}
9002impl core::ops::Not for FramebufferCreateFlagBits {
9003    type Output = Self;
9004    #[inline]
9005    fn not(self) -> Self {
9006        Self(!self.0)
9007    }
9008}
9009impl core::fmt::Debug for FramebufferCreateFlagBits {
9010    #[allow(unused_mut, unused_variables)]
9011    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9012        let mut first = true;
9013        let mut remaining = self.0;
9014        if remaining & Self::IMAGELESS.0 != 0 {
9015            if !first {
9016                f.write_str(" | ")?;
9017            }
9018            f.write_str("IMAGELESS")?;
9019            remaining &= !Self::IMAGELESS.0;
9020            first = false;
9021        }
9022        if remaining != 0u32 {
9023            if !first {
9024                f.write_str(" | ")?;
9025            }
9026            write!(f, "{:#x}", remaining)?;
9027        } else if first {
9028            f.write_str("(empty)")?;
9029        }
9030        Ok(())
9031    }
9032}
9033///[`VkGeometryFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryFlagBitsKHR.html)
9034#[repr(transparent)]
9035#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
9036#[doc(alias = "VkGeometryFlagBitsKHR")]
9037pub struct GeometryFlagBitsKHR(u32);
9038impl GeometryFlagBitsKHR {
9039    #[inline]
9040    pub const fn empty() -> Self {
9041        Self(0u32)
9042    }
9043    #[inline]
9044    pub const fn from_raw(value: u32) -> Self {
9045        Self(value)
9046    }
9047    #[inline]
9048    pub const fn as_raw(self) -> u32 {
9049        self.0
9050    }
9051    #[inline]
9052    pub const fn is_empty(self) -> bool {
9053        self.0 == 0u32
9054    }
9055    #[inline]
9056    pub const fn contains(self, other: Self) -> bool {
9057        (self.0 & other.0) == other.0
9058    }
9059    ///Bit 0.
9060    pub const OPAQUE: Self = Self(1u32);
9061    ///Bit 1.
9062    pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(2u32);
9063}
9064impl core::ops::BitOr for GeometryFlagBitsKHR {
9065    type Output = Self;
9066    #[inline]
9067    fn bitor(self, rhs: Self) -> Self {
9068        Self(self.0 | rhs.0)
9069    }
9070}
9071impl core::ops::BitOrAssign for GeometryFlagBitsKHR {
9072    #[inline]
9073    fn bitor_assign(&mut self, rhs: Self) {
9074        self.0 |= rhs.0;
9075    }
9076}
9077impl core::ops::BitAnd for GeometryFlagBitsKHR {
9078    type Output = Self;
9079    #[inline]
9080    fn bitand(self, rhs: Self) -> Self {
9081        Self(self.0 & rhs.0)
9082    }
9083}
9084impl core::ops::BitAndAssign for GeometryFlagBitsKHR {
9085    #[inline]
9086    fn bitand_assign(&mut self, rhs: Self) {
9087        self.0 &= rhs.0;
9088    }
9089}
9090impl core::ops::BitXor for GeometryFlagBitsKHR {
9091    type Output = Self;
9092    #[inline]
9093    fn bitxor(self, rhs: Self) -> Self {
9094        Self(self.0 ^ rhs.0)
9095    }
9096}
9097impl core::ops::BitXorAssign for GeometryFlagBitsKHR {
9098    #[inline]
9099    fn bitxor_assign(&mut self, rhs: Self) {
9100        self.0 ^= rhs.0;
9101    }
9102}
9103impl core::ops::Not for GeometryFlagBitsKHR {
9104    type Output = Self;
9105    #[inline]
9106    fn not(self) -> Self {
9107        Self(!self.0)
9108    }
9109}
9110impl core::fmt::Debug for GeometryFlagBitsKHR {
9111    #[allow(unused_mut, unused_variables)]
9112    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9113        let mut first = true;
9114        let mut remaining = self.0;
9115        if remaining & Self::OPAQUE.0 != 0 {
9116            if !first {
9117                f.write_str(" | ")?;
9118            }
9119            f.write_str("OPAQUE")?;
9120            remaining &= !Self::OPAQUE.0;
9121            first = false;
9122        }
9123        if remaining & Self::NO_DUPLICATE_ANY_HIT_INVOCATION.0 != 0 {
9124            if !first {
9125                f.write_str(" | ")?;
9126            }
9127            f.write_str("NO_DUPLICATE_ANY_HIT_INVOCATION")?;
9128            remaining &= !Self::NO_DUPLICATE_ANY_HIT_INVOCATION.0;
9129            first = false;
9130        }
9131        if remaining != 0u32 {
9132            if !first {
9133                f.write_str(" | ")?;
9134            }
9135            write!(f, "{:#x}", remaining)?;
9136        } else if first {
9137            f.write_str("(empty)")?;
9138        }
9139        Ok(())
9140    }
9141}
9142///[`VkGeometryInstanceFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryInstanceFlagBitsKHR.html)
9143#[repr(transparent)]
9144#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
9145#[doc(alias = "VkGeometryInstanceFlagBitsKHR")]
9146pub struct GeometryInstanceFlagBitsKHR(u32);
9147impl GeometryInstanceFlagBitsKHR {
9148    #[inline]
9149    pub const fn empty() -> Self {
9150        Self(0u32)
9151    }
9152    #[inline]
9153    pub const fn from_raw(value: u32) -> Self {
9154        Self(value)
9155    }
9156    #[inline]
9157    pub const fn as_raw(self) -> u32 {
9158        self.0
9159    }
9160    #[inline]
9161    pub const fn is_empty(self) -> bool {
9162        self.0 == 0u32
9163    }
9164    #[inline]
9165    pub const fn contains(self, other: Self) -> bool {
9166        (self.0 & other.0) == other.0
9167    }
9168    ///Bit 0.
9169    pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(1u32);
9170    ///Bit 1.
9171    pub const TRIANGLE_FLIP_FACING: Self = Self(2u32);
9172    ///Bit 2.
9173    pub const FORCE_OPAQUE: Self = Self(4u32);
9174    ///Bit 3.
9175    pub const FORCE_NO_OPAQUE: Self = Self(8u32);
9176    pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = Self::TRIANGLE_FLIP_FACING;
9177    pub const TRIANGLE_CULL_DISABLE: Self = Self::TRIANGLE_FACING_CULL_DISABLE;
9178    ///Bit 4.
9179    pub const FORCE_OPACITY_MICROMAP_2_STATE: Self = Self(16u32);
9180    ///Bit 5.
9181    pub const DISABLE_OPACITY_MICROMAPS: Self = Self(32u32);
9182}
9183impl core::ops::BitOr for GeometryInstanceFlagBitsKHR {
9184    type Output = Self;
9185    #[inline]
9186    fn bitor(self, rhs: Self) -> Self {
9187        Self(self.0 | rhs.0)
9188    }
9189}
9190impl core::ops::BitOrAssign for GeometryInstanceFlagBitsKHR {
9191    #[inline]
9192    fn bitor_assign(&mut self, rhs: Self) {
9193        self.0 |= rhs.0;
9194    }
9195}
9196impl core::ops::BitAnd for GeometryInstanceFlagBitsKHR {
9197    type Output = Self;
9198    #[inline]
9199    fn bitand(self, rhs: Self) -> Self {
9200        Self(self.0 & rhs.0)
9201    }
9202}
9203impl core::ops::BitAndAssign for GeometryInstanceFlagBitsKHR {
9204    #[inline]
9205    fn bitand_assign(&mut self, rhs: Self) {
9206        self.0 &= rhs.0;
9207    }
9208}
9209impl core::ops::BitXor for GeometryInstanceFlagBitsKHR {
9210    type Output = Self;
9211    #[inline]
9212    fn bitxor(self, rhs: Self) -> Self {
9213        Self(self.0 ^ rhs.0)
9214    }
9215}
9216impl core::ops::BitXorAssign for GeometryInstanceFlagBitsKHR {
9217    #[inline]
9218    fn bitxor_assign(&mut self, rhs: Self) {
9219        self.0 ^= rhs.0;
9220    }
9221}
9222impl core::ops::Not for GeometryInstanceFlagBitsKHR {
9223    type Output = Self;
9224    #[inline]
9225    fn not(self) -> Self {
9226        Self(!self.0)
9227    }
9228}
9229impl core::fmt::Debug for GeometryInstanceFlagBitsKHR {
9230    #[allow(unused_mut, unused_variables)]
9231    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9232        let mut first = true;
9233        let mut remaining = self.0;
9234        if remaining & Self::TRIANGLE_FACING_CULL_DISABLE.0 != 0 {
9235            if !first {
9236                f.write_str(" | ")?;
9237            }
9238            f.write_str("TRIANGLE_FACING_CULL_DISABLE")?;
9239            remaining &= !Self::TRIANGLE_FACING_CULL_DISABLE.0;
9240            first = false;
9241        }
9242        if remaining & Self::TRIANGLE_FLIP_FACING.0 != 0 {
9243            if !first {
9244                f.write_str(" | ")?;
9245            }
9246            f.write_str("TRIANGLE_FLIP_FACING")?;
9247            remaining &= !Self::TRIANGLE_FLIP_FACING.0;
9248            first = false;
9249        }
9250        if remaining & Self::FORCE_OPAQUE.0 != 0 {
9251            if !first {
9252                f.write_str(" | ")?;
9253            }
9254            f.write_str("FORCE_OPAQUE")?;
9255            remaining &= !Self::FORCE_OPAQUE.0;
9256            first = false;
9257        }
9258        if remaining & Self::FORCE_NO_OPAQUE.0 != 0 {
9259            if !first {
9260                f.write_str(" | ")?;
9261            }
9262            f.write_str("FORCE_NO_OPAQUE")?;
9263            remaining &= !Self::FORCE_NO_OPAQUE.0;
9264            first = false;
9265        }
9266        if remaining & Self::FORCE_OPACITY_MICROMAP_2_STATE.0 != 0 {
9267            if !first {
9268                f.write_str(" | ")?;
9269            }
9270            f.write_str("FORCE_OPACITY_MICROMAP_2_STATE")?;
9271            remaining &= !Self::FORCE_OPACITY_MICROMAP_2_STATE.0;
9272            first = false;
9273        }
9274        if remaining & Self::DISABLE_OPACITY_MICROMAPS.0 != 0 {
9275            if !first {
9276                f.write_str(" | ")?;
9277            }
9278            f.write_str("DISABLE_OPACITY_MICROMAPS")?;
9279            remaining &= !Self::DISABLE_OPACITY_MICROMAPS.0;
9280            first = false;
9281        }
9282        if remaining != 0u32 {
9283            if !first {
9284                f.write_str(" | ")?;
9285            }
9286            write!(f, "{:#x}", remaining)?;
9287        } else if first {
9288            f.write_str("(empty)")?;
9289        }
9290        Ok(())
9291    }
9292}
9293///[`VkGraphicsPipelineLibraryFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryFlagBitsEXT.html)
9294#[repr(transparent)]
9295#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
9296#[doc(alias = "VkGraphicsPipelineLibraryFlagBitsEXT")]
9297pub struct GraphicsPipelineLibraryFlagBitsEXT(u32);
9298impl GraphicsPipelineLibraryFlagBitsEXT {
9299    #[inline]
9300    pub const fn empty() -> Self {
9301        Self(0u32)
9302    }
9303    #[inline]
9304    pub const fn from_raw(value: u32) -> Self {
9305        Self(value)
9306    }
9307    #[inline]
9308    pub const fn as_raw(self) -> u32 {
9309        self.0
9310    }
9311    #[inline]
9312    pub const fn is_empty(self) -> bool {
9313        self.0 == 0u32
9314    }
9315    #[inline]
9316    pub const fn contains(self, other: Self) -> bool {
9317        (self.0 & other.0) == other.0
9318    }
9319    ///Bit 0.
9320    pub const VERTEX_INPUT_INTERFACE: Self = Self(1u32);
9321    ///Bit 1.
9322    pub const PRE_RASTERIZATION_SHADERS: Self = Self(2u32);
9323    ///Bit 2.
9324    pub const FRAGMENT_SHADER: Self = Self(4u32);
9325    ///Bit 3.
9326    pub const FRAGMENT_OUTPUT_INTERFACE: Self = Self(8u32);
9327}
9328impl core::ops::BitOr for GraphicsPipelineLibraryFlagBitsEXT {
9329    type Output = Self;
9330    #[inline]
9331    fn bitor(self, rhs: Self) -> Self {
9332        Self(self.0 | rhs.0)
9333    }
9334}
9335impl core::ops::BitOrAssign for GraphicsPipelineLibraryFlagBitsEXT {
9336    #[inline]
9337    fn bitor_assign(&mut self, rhs: Self) {
9338        self.0 |= rhs.0;
9339    }
9340}
9341impl core::ops::BitAnd for GraphicsPipelineLibraryFlagBitsEXT {
9342    type Output = Self;
9343    #[inline]
9344    fn bitand(self, rhs: Self) -> Self {
9345        Self(self.0 & rhs.0)
9346    }
9347}
9348impl core::ops::BitAndAssign for GraphicsPipelineLibraryFlagBitsEXT {
9349    #[inline]
9350    fn bitand_assign(&mut self, rhs: Self) {
9351        self.0 &= rhs.0;
9352    }
9353}
9354impl core::ops::BitXor for GraphicsPipelineLibraryFlagBitsEXT {
9355    type Output = Self;
9356    #[inline]
9357    fn bitxor(self, rhs: Self) -> Self {
9358        Self(self.0 ^ rhs.0)
9359    }
9360}
9361impl core::ops::BitXorAssign for GraphicsPipelineLibraryFlagBitsEXT {
9362    #[inline]
9363    fn bitxor_assign(&mut self, rhs: Self) {
9364        self.0 ^= rhs.0;
9365    }
9366}
9367impl core::ops::Not for GraphicsPipelineLibraryFlagBitsEXT {
9368    type Output = Self;
9369    #[inline]
9370    fn not(self) -> Self {
9371        Self(!self.0)
9372    }
9373}
9374impl core::fmt::Debug for GraphicsPipelineLibraryFlagBitsEXT {
9375    #[allow(unused_mut, unused_variables)]
9376    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9377        let mut first = true;
9378        let mut remaining = self.0;
9379        if remaining & Self::VERTEX_INPUT_INTERFACE.0 != 0 {
9380            if !first {
9381                f.write_str(" | ")?;
9382            }
9383            f.write_str("VERTEX_INPUT_INTERFACE")?;
9384            remaining &= !Self::VERTEX_INPUT_INTERFACE.0;
9385            first = false;
9386        }
9387        if remaining & Self::PRE_RASTERIZATION_SHADERS.0 != 0 {
9388            if !first {
9389                f.write_str(" | ")?;
9390            }
9391            f.write_str("PRE_RASTERIZATION_SHADERS")?;
9392            remaining &= !Self::PRE_RASTERIZATION_SHADERS.0;
9393            first = false;
9394        }
9395        if remaining & Self::FRAGMENT_SHADER.0 != 0 {
9396            if !first {
9397                f.write_str(" | ")?;
9398            }
9399            f.write_str("FRAGMENT_SHADER")?;
9400            remaining &= !Self::FRAGMENT_SHADER.0;
9401            first = false;
9402        }
9403        if remaining & Self::FRAGMENT_OUTPUT_INTERFACE.0 != 0 {
9404            if !first {
9405                f.write_str(" | ")?;
9406            }
9407            f.write_str("FRAGMENT_OUTPUT_INTERFACE")?;
9408            remaining &= !Self::FRAGMENT_OUTPUT_INTERFACE.0;
9409            first = false;
9410        }
9411        if remaining != 0u32 {
9412            if !first {
9413                f.write_str(" | ")?;
9414            }
9415            write!(f, "{:#x}", remaining)?;
9416        } else if first {
9417            f.write_str("(empty)")?;
9418        }
9419        Ok(())
9420    }
9421}
9422///[`VkHostImageCopyFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageCopyFlagBits.html)
9423#[repr(transparent)]
9424#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
9425#[doc(alias = "VkHostImageCopyFlagBits")]
9426pub struct HostImageCopyFlagBits(u32);
9427impl HostImageCopyFlagBits {
9428    #[inline]
9429    pub const fn empty() -> Self {
9430        Self(0u32)
9431    }
9432    #[inline]
9433    pub const fn from_raw(value: u32) -> Self {
9434        Self(value)
9435    }
9436    #[inline]
9437    pub const fn as_raw(self) -> u32 {
9438        self.0
9439    }
9440    #[inline]
9441    pub const fn is_empty(self) -> bool {
9442        self.0 == 0u32
9443    }
9444    #[inline]
9445    pub const fn contains(self, other: Self) -> bool {
9446        (self.0 & other.0) == other.0
9447    }
9448    ///Bit 0.
9449    pub const MEMCPY: Self = Self(1u32);
9450}
9451impl core::ops::BitOr for HostImageCopyFlagBits {
9452    type Output = Self;
9453    #[inline]
9454    fn bitor(self, rhs: Self) -> Self {
9455        Self(self.0 | rhs.0)
9456    }
9457}
9458impl core::ops::BitOrAssign for HostImageCopyFlagBits {
9459    #[inline]
9460    fn bitor_assign(&mut self, rhs: Self) {
9461        self.0 |= rhs.0;
9462    }
9463}
9464impl core::ops::BitAnd for HostImageCopyFlagBits {
9465    type Output = Self;
9466    #[inline]
9467    fn bitand(self, rhs: Self) -> Self {
9468        Self(self.0 & rhs.0)
9469    }
9470}
9471impl core::ops::BitAndAssign for HostImageCopyFlagBits {
9472    #[inline]
9473    fn bitand_assign(&mut self, rhs: Self) {
9474        self.0 &= rhs.0;
9475    }
9476}
9477impl core::ops::BitXor for HostImageCopyFlagBits {
9478    type Output = Self;
9479    #[inline]
9480    fn bitxor(self, rhs: Self) -> Self {
9481        Self(self.0 ^ rhs.0)
9482    }
9483}
9484impl core::ops::BitXorAssign for HostImageCopyFlagBits {
9485    #[inline]
9486    fn bitxor_assign(&mut self, rhs: Self) {
9487        self.0 ^= rhs.0;
9488    }
9489}
9490impl core::ops::Not for HostImageCopyFlagBits {
9491    type Output = Self;
9492    #[inline]
9493    fn not(self) -> Self {
9494        Self(!self.0)
9495    }
9496}
9497impl core::fmt::Debug for HostImageCopyFlagBits {
9498    #[allow(unused_mut, unused_variables)]
9499    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9500        let mut first = true;
9501        let mut remaining = self.0;
9502        if remaining & Self::MEMCPY.0 != 0 {
9503            if !first {
9504                f.write_str(" | ")?;
9505            }
9506            f.write_str("MEMCPY")?;
9507            remaining &= !Self::MEMCPY.0;
9508            first = false;
9509        }
9510        if remaining != 0u32 {
9511            if !first {
9512                f.write_str(" | ")?;
9513            }
9514            write!(f, "{:#x}", remaining)?;
9515        } else if first {
9516            f.write_str("(empty)")?;
9517        }
9518        Ok(())
9519    }
9520}
9521///[`VkImageAspectFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageAspectFlagBits.html)
9522#[repr(transparent)]
9523#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
9524#[doc(alias = "VkImageAspectFlagBits")]
9525pub struct ImageAspectFlagBits(u32);
9526impl ImageAspectFlagBits {
9527    #[inline]
9528    pub const fn empty() -> Self {
9529        Self(0u32)
9530    }
9531    #[inline]
9532    pub const fn from_raw(value: u32) -> Self {
9533        Self(value)
9534    }
9535    #[inline]
9536    pub const fn as_raw(self) -> u32 {
9537        self.0
9538    }
9539    #[inline]
9540    pub const fn is_empty(self) -> bool {
9541        self.0 == 0u32
9542    }
9543    #[inline]
9544    pub const fn contains(self, other: Self) -> bool {
9545        (self.0 & other.0) == other.0
9546    }
9547    ///Bit 0.
9548    pub const COLOR: Self = Self(1u32);
9549    ///Bit 1.
9550    pub const DEPTH: Self = Self(2u32);
9551    ///Bit 2.
9552    pub const STENCIL: Self = Self(4u32);
9553    ///Bit 3.
9554    pub const METADATA: Self = Self(8u32);
9555    ///Bit 4.
9556    pub const PLANE_0: Self = Self(16u32);
9557    ///Bit 5.
9558    pub const PLANE_1: Self = Self(32u32);
9559    ///Bit 6.
9560    pub const PLANE_2: Self = Self(64u32);
9561    pub const NONE: Self = Self(0u32);
9562    ///Bit 7.
9563    pub const MEMORY_PLANE_0: Self = Self(128u32);
9564    ///Bit 8.
9565    pub const MEMORY_PLANE_1: Self = Self(256u32);
9566    ///Bit 9.
9567    pub const MEMORY_PLANE_2: Self = Self(512u32);
9568    ///Bit 10.
9569    pub const MEMORY_PLANE_3: Self = Self(1024u32);
9570}
9571impl core::ops::BitOr for ImageAspectFlagBits {
9572    type Output = Self;
9573    #[inline]
9574    fn bitor(self, rhs: Self) -> Self {
9575        Self(self.0 | rhs.0)
9576    }
9577}
9578impl core::ops::BitOrAssign for ImageAspectFlagBits {
9579    #[inline]
9580    fn bitor_assign(&mut self, rhs: Self) {
9581        self.0 |= rhs.0;
9582    }
9583}
9584impl core::ops::BitAnd for ImageAspectFlagBits {
9585    type Output = Self;
9586    #[inline]
9587    fn bitand(self, rhs: Self) -> Self {
9588        Self(self.0 & rhs.0)
9589    }
9590}
9591impl core::ops::BitAndAssign for ImageAspectFlagBits {
9592    #[inline]
9593    fn bitand_assign(&mut self, rhs: Self) {
9594        self.0 &= rhs.0;
9595    }
9596}
9597impl core::ops::BitXor for ImageAspectFlagBits {
9598    type Output = Self;
9599    #[inline]
9600    fn bitxor(self, rhs: Self) -> Self {
9601        Self(self.0 ^ rhs.0)
9602    }
9603}
9604impl core::ops::BitXorAssign for ImageAspectFlagBits {
9605    #[inline]
9606    fn bitxor_assign(&mut self, rhs: Self) {
9607        self.0 ^= rhs.0;
9608    }
9609}
9610impl core::ops::Not for ImageAspectFlagBits {
9611    type Output = Self;
9612    #[inline]
9613    fn not(self) -> Self {
9614        Self(!self.0)
9615    }
9616}
9617impl core::fmt::Debug for ImageAspectFlagBits {
9618    #[allow(unused_mut, unused_variables)]
9619    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9620        let mut first = true;
9621        let mut remaining = self.0;
9622        if remaining & Self::COLOR.0 != 0 {
9623            if !first {
9624                f.write_str(" | ")?;
9625            }
9626            f.write_str("COLOR")?;
9627            remaining &= !Self::COLOR.0;
9628            first = false;
9629        }
9630        if remaining & Self::DEPTH.0 != 0 {
9631            if !first {
9632                f.write_str(" | ")?;
9633            }
9634            f.write_str("DEPTH")?;
9635            remaining &= !Self::DEPTH.0;
9636            first = false;
9637        }
9638        if remaining & Self::STENCIL.0 != 0 {
9639            if !first {
9640                f.write_str(" | ")?;
9641            }
9642            f.write_str("STENCIL")?;
9643            remaining &= !Self::STENCIL.0;
9644            first = false;
9645        }
9646        if remaining & Self::METADATA.0 != 0 {
9647            if !first {
9648                f.write_str(" | ")?;
9649            }
9650            f.write_str("METADATA")?;
9651            remaining &= !Self::METADATA.0;
9652            first = false;
9653        }
9654        if remaining & Self::PLANE_0.0 != 0 {
9655            if !first {
9656                f.write_str(" | ")?;
9657            }
9658            f.write_str("PLANE_0")?;
9659            remaining &= !Self::PLANE_0.0;
9660            first = false;
9661        }
9662        if remaining & Self::PLANE_1.0 != 0 {
9663            if !first {
9664                f.write_str(" | ")?;
9665            }
9666            f.write_str("PLANE_1")?;
9667            remaining &= !Self::PLANE_1.0;
9668            first = false;
9669        }
9670        if remaining & Self::PLANE_2.0 != 0 {
9671            if !first {
9672                f.write_str(" | ")?;
9673            }
9674            f.write_str("PLANE_2")?;
9675            remaining &= !Self::PLANE_2.0;
9676            first = false;
9677        }
9678        if remaining & Self::MEMORY_PLANE_0.0 != 0 {
9679            if !first {
9680                f.write_str(" | ")?;
9681            }
9682            f.write_str("MEMORY_PLANE_0")?;
9683            remaining &= !Self::MEMORY_PLANE_0.0;
9684            first = false;
9685        }
9686        if remaining & Self::MEMORY_PLANE_1.0 != 0 {
9687            if !first {
9688                f.write_str(" | ")?;
9689            }
9690            f.write_str("MEMORY_PLANE_1")?;
9691            remaining &= !Self::MEMORY_PLANE_1.0;
9692            first = false;
9693        }
9694        if remaining & Self::MEMORY_PLANE_2.0 != 0 {
9695            if !first {
9696                f.write_str(" | ")?;
9697            }
9698            f.write_str("MEMORY_PLANE_2")?;
9699            remaining &= !Self::MEMORY_PLANE_2.0;
9700            first = false;
9701        }
9702        if remaining & Self::MEMORY_PLANE_3.0 != 0 {
9703            if !first {
9704                f.write_str(" | ")?;
9705            }
9706            f.write_str("MEMORY_PLANE_3")?;
9707            remaining &= !Self::MEMORY_PLANE_3.0;
9708            first = false;
9709        }
9710        if remaining != 0u32 {
9711            if !first {
9712                f.write_str(" | ")?;
9713            }
9714            write!(f, "{:#x}", remaining)?;
9715        } else if first {
9716            f.write_str("(empty)")?;
9717        }
9718        Ok(())
9719    }
9720}
9721///[`VkImageCompressionFixedRateFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFixedRateFlagBitsEXT.html)
9722#[repr(transparent)]
9723#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
9724#[doc(alias = "VkImageCompressionFixedRateFlagBitsEXT")]
9725pub struct ImageCompressionFixedRateFlagBitsEXT(u32);
9726impl ImageCompressionFixedRateFlagBitsEXT {
9727    #[inline]
9728    pub const fn empty() -> Self {
9729        Self(0u32)
9730    }
9731    #[inline]
9732    pub const fn from_raw(value: u32) -> Self {
9733        Self(value)
9734    }
9735    #[inline]
9736    pub const fn as_raw(self) -> u32 {
9737        self.0
9738    }
9739    #[inline]
9740    pub const fn is_empty(self) -> bool {
9741        self.0 == 0u32
9742    }
9743    #[inline]
9744    pub const fn contains(self, other: Self) -> bool {
9745        (self.0 & other.0) == other.0
9746    }
9747    pub const NONE: Self = Self(0u32);
9748    ///Bit 0.
9749    pub const _1BPC: Self = Self(1u32);
9750    ///Bit 1.
9751    pub const _2BPC: Self = Self(2u32);
9752    ///Bit 2.
9753    pub const _3BPC: Self = Self(4u32);
9754    ///Bit 3.
9755    pub const _4BPC: Self = Self(8u32);
9756    ///Bit 4.
9757    pub const _5BPC: Self = Self(16u32);
9758    ///Bit 5.
9759    pub const _6BPC: Self = Self(32u32);
9760    ///Bit 6.
9761    pub const _7BPC: Self = Self(64u32);
9762    ///Bit 7.
9763    pub const _8BPC: Self = Self(128u32);
9764    ///Bit 8.
9765    pub const _9BPC: Self = Self(256u32);
9766    ///Bit 9.
9767    pub const _10BPC: Self = Self(512u32);
9768    ///Bit 10.
9769    pub const _11BPC: Self = Self(1024u32);
9770    ///Bit 11.
9771    pub const _12BPC: Self = Self(2048u32);
9772    ///Bit 12.
9773    pub const _13BPC: Self = Self(4096u32);
9774    ///Bit 13.
9775    pub const _14BPC: Self = Self(8192u32);
9776    ///Bit 14.
9777    pub const _15BPC: Self = Self(16384u32);
9778    ///Bit 15.
9779    pub const _16BPC: Self = Self(32768u32);
9780    ///Bit 16.
9781    pub const _17BPC: Self = Self(65536u32);
9782    ///Bit 17.
9783    pub const _18BPC: Self = Self(131072u32);
9784    ///Bit 18.
9785    pub const _19BPC: Self = Self(262144u32);
9786    ///Bit 19.
9787    pub const _20BPC: Self = Self(524288u32);
9788    ///Bit 20.
9789    pub const _21BPC: Self = Self(1048576u32);
9790    ///Bit 21.
9791    pub const _22BPC: Self = Self(2097152u32);
9792    ///Bit 22.
9793    pub const _23BPC: Self = Self(4194304u32);
9794    ///Bit 23.
9795    pub const _24BPC: Self = Self(8388608u32);
9796}
9797impl core::ops::BitOr for ImageCompressionFixedRateFlagBitsEXT {
9798    type Output = Self;
9799    #[inline]
9800    fn bitor(self, rhs: Self) -> Self {
9801        Self(self.0 | rhs.0)
9802    }
9803}
9804impl core::ops::BitOrAssign for ImageCompressionFixedRateFlagBitsEXT {
9805    #[inline]
9806    fn bitor_assign(&mut self, rhs: Self) {
9807        self.0 |= rhs.0;
9808    }
9809}
9810impl core::ops::BitAnd for ImageCompressionFixedRateFlagBitsEXT {
9811    type Output = Self;
9812    #[inline]
9813    fn bitand(self, rhs: Self) -> Self {
9814        Self(self.0 & rhs.0)
9815    }
9816}
9817impl core::ops::BitAndAssign for ImageCompressionFixedRateFlagBitsEXT {
9818    #[inline]
9819    fn bitand_assign(&mut self, rhs: Self) {
9820        self.0 &= rhs.0;
9821    }
9822}
9823impl core::ops::BitXor for ImageCompressionFixedRateFlagBitsEXT {
9824    type Output = Self;
9825    #[inline]
9826    fn bitxor(self, rhs: Self) -> Self {
9827        Self(self.0 ^ rhs.0)
9828    }
9829}
9830impl core::ops::BitXorAssign for ImageCompressionFixedRateFlagBitsEXT {
9831    #[inline]
9832    fn bitxor_assign(&mut self, rhs: Self) {
9833        self.0 ^= rhs.0;
9834    }
9835}
9836impl core::ops::Not for ImageCompressionFixedRateFlagBitsEXT {
9837    type Output = Self;
9838    #[inline]
9839    fn not(self) -> Self {
9840        Self(!self.0)
9841    }
9842}
9843impl core::fmt::Debug for ImageCompressionFixedRateFlagBitsEXT {
9844    #[allow(unused_mut, unused_variables)]
9845    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9846        let mut first = true;
9847        let mut remaining = self.0;
9848        if remaining & Self::_1BPC.0 != 0 {
9849            if !first {
9850                f.write_str(" | ")?;
9851            }
9852            f.write_str("_1BPC")?;
9853            remaining &= !Self::_1BPC.0;
9854            first = false;
9855        }
9856        if remaining & Self::_2BPC.0 != 0 {
9857            if !first {
9858                f.write_str(" | ")?;
9859            }
9860            f.write_str("_2BPC")?;
9861            remaining &= !Self::_2BPC.0;
9862            first = false;
9863        }
9864        if remaining & Self::_3BPC.0 != 0 {
9865            if !first {
9866                f.write_str(" | ")?;
9867            }
9868            f.write_str("_3BPC")?;
9869            remaining &= !Self::_3BPC.0;
9870            first = false;
9871        }
9872        if remaining & Self::_4BPC.0 != 0 {
9873            if !first {
9874                f.write_str(" | ")?;
9875            }
9876            f.write_str("_4BPC")?;
9877            remaining &= !Self::_4BPC.0;
9878            first = false;
9879        }
9880        if remaining & Self::_5BPC.0 != 0 {
9881            if !first {
9882                f.write_str(" | ")?;
9883            }
9884            f.write_str("_5BPC")?;
9885            remaining &= !Self::_5BPC.0;
9886            first = false;
9887        }
9888        if remaining & Self::_6BPC.0 != 0 {
9889            if !first {
9890                f.write_str(" | ")?;
9891            }
9892            f.write_str("_6BPC")?;
9893            remaining &= !Self::_6BPC.0;
9894            first = false;
9895        }
9896        if remaining & Self::_7BPC.0 != 0 {
9897            if !first {
9898                f.write_str(" | ")?;
9899            }
9900            f.write_str("_7BPC")?;
9901            remaining &= !Self::_7BPC.0;
9902            first = false;
9903        }
9904        if remaining & Self::_8BPC.0 != 0 {
9905            if !first {
9906                f.write_str(" | ")?;
9907            }
9908            f.write_str("_8BPC")?;
9909            remaining &= !Self::_8BPC.0;
9910            first = false;
9911        }
9912        if remaining & Self::_9BPC.0 != 0 {
9913            if !first {
9914                f.write_str(" | ")?;
9915            }
9916            f.write_str("_9BPC")?;
9917            remaining &= !Self::_9BPC.0;
9918            first = false;
9919        }
9920        if remaining & Self::_10BPC.0 != 0 {
9921            if !first {
9922                f.write_str(" | ")?;
9923            }
9924            f.write_str("_10BPC")?;
9925            remaining &= !Self::_10BPC.0;
9926            first = false;
9927        }
9928        if remaining & Self::_11BPC.0 != 0 {
9929            if !first {
9930                f.write_str(" | ")?;
9931            }
9932            f.write_str("_11BPC")?;
9933            remaining &= !Self::_11BPC.0;
9934            first = false;
9935        }
9936        if remaining & Self::_12BPC.0 != 0 {
9937            if !first {
9938                f.write_str(" | ")?;
9939            }
9940            f.write_str("_12BPC")?;
9941            remaining &= !Self::_12BPC.0;
9942            first = false;
9943        }
9944        if remaining & Self::_13BPC.0 != 0 {
9945            if !first {
9946                f.write_str(" | ")?;
9947            }
9948            f.write_str("_13BPC")?;
9949            remaining &= !Self::_13BPC.0;
9950            first = false;
9951        }
9952        if remaining & Self::_14BPC.0 != 0 {
9953            if !first {
9954                f.write_str(" | ")?;
9955            }
9956            f.write_str("_14BPC")?;
9957            remaining &= !Self::_14BPC.0;
9958            first = false;
9959        }
9960        if remaining & Self::_15BPC.0 != 0 {
9961            if !first {
9962                f.write_str(" | ")?;
9963            }
9964            f.write_str("_15BPC")?;
9965            remaining &= !Self::_15BPC.0;
9966            first = false;
9967        }
9968        if remaining & Self::_16BPC.0 != 0 {
9969            if !first {
9970                f.write_str(" | ")?;
9971            }
9972            f.write_str("_16BPC")?;
9973            remaining &= !Self::_16BPC.0;
9974            first = false;
9975        }
9976        if remaining & Self::_17BPC.0 != 0 {
9977            if !first {
9978                f.write_str(" | ")?;
9979            }
9980            f.write_str("_17BPC")?;
9981            remaining &= !Self::_17BPC.0;
9982            first = false;
9983        }
9984        if remaining & Self::_18BPC.0 != 0 {
9985            if !first {
9986                f.write_str(" | ")?;
9987            }
9988            f.write_str("_18BPC")?;
9989            remaining &= !Self::_18BPC.0;
9990            first = false;
9991        }
9992        if remaining & Self::_19BPC.0 != 0 {
9993            if !first {
9994                f.write_str(" | ")?;
9995            }
9996            f.write_str("_19BPC")?;
9997            remaining &= !Self::_19BPC.0;
9998            first = false;
9999        }
10000        if remaining & Self::_20BPC.0 != 0 {
10001            if !first {
10002                f.write_str(" | ")?;
10003            }
10004            f.write_str("_20BPC")?;
10005            remaining &= !Self::_20BPC.0;
10006            first = false;
10007        }
10008        if remaining & Self::_21BPC.0 != 0 {
10009            if !first {
10010                f.write_str(" | ")?;
10011            }
10012            f.write_str("_21BPC")?;
10013            remaining &= !Self::_21BPC.0;
10014            first = false;
10015        }
10016        if remaining & Self::_22BPC.0 != 0 {
10017            if !first {
10018                f.write_str(" | ")?;
10019            }
10020            f.write_str("_22BPC")?;
10021            remaining &= !Self::_22BPC.0;
10022            first = false;
10023        }
10024        if remaining & Self::_23BPC.0 != 0 {
10025            if !first {
10026                f.write_str(" | ")?;
10027            }
10028            f.write_str("_23BPC")?;
10029            remaining &= !Self::_23BPC.0;
10030            first = false;
10031        }
10032        if remaining & Self::_24BPC.0 != 0 {
10033            if !first {
10034                f.write_str(" | ")?;
10035            }
10036            f.write_str("_24BPC")?;
10037            remaining &= !Self::_24BPC.0;
10038            first = false;
10039        }
10040        if remaining != 0u32 {
10041            if !first {
10042                f.write_str(" | ")?;
10043            }
10044            write!(f, "{:#x}", remaining)?;
10045        } else if first {
10046            f.write_str("(empty)")?;
10047        }
10048        Ok(())
10049    }
10050}
10051///[`VkImageCompressionFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFlagBitsEXT.html)
10052#[repr(transparent)]
10053#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
10054#[doc(alias = "VkImageCompressionFlagBitsEXT")]
10055pub struct ImageCompressionFlagBitsEXT(u32);
10056impl ImageCompressionFlagBitsEXT {
10057    #[inline]
10058    pub const fn empty() -> Self {
10059        Self(0u32)
10060    }
10061    #[inline]
10062    pub const fn from_raw(value: u32) -> Self {
10063        Self(value)
10064    }
10065    #[inline]
10066    pub const fn as_raw(self) -> u32 {
10067        self.0
10068    }
10069    #[inline]
10070    pub const fn is_empty(self) -> bool {
10071        self.0 == 0u32
10072    }
10073    #[inline]
10074    pub const fn contains(self, other: Self) -> bool {
10075        (self.0 & other.0) == other.0
10076    }
10077    pub const DEFAULT: Self = Self(0u32);
10078    ///Bit 0.
10079    pub const FIXED_RATE_DEFAULT: Self = Self(1u32);
10080    ///Bit 1.
10081    pub const FIXED_RATE_EXPLICIT: Self = Self(2u32);
10082    ///Bit 2.
10083    pub const DISABLED: Self = Self(4u32);
10084}
10085impl core::ops::BitOr for ImageCompressionFlagBitsEXT {
10086    type Output = Self;
10087    #[inline]
10088    fn bitor(self, rhs: Self) -> Self {
10089        Self(self.0 | rhs.0)
10090    }
10091}
10092impl core::ops::BitOrAssign for ImageCompressionFlagBitsEXT {
10093    #[inline]
10094    fn bitor_assign(&mut self, rhs: Self) {
10095        self.0 |= rhs.0;
10096    }
10097}
10098impl core::ops::BitAnd for ImageCompressionFlagBitsEXT {
10099    type Output = Self;
10100    #[inline]
10101    fn bitand(self, rhs: Self) -> Self {
10102        Self(self.0 & rhs.0)
10103    }
10104}
10105impl core::ops::BitAndAssign for ImageCompressionFlagBitsEXT {
10106    #[inline]
10107    fn bitand_assign(&mut self, rhs: Self) {
10108        self.0 &= rhs.0;
10109    }
10110}
10111impl core::ops::BitXor for ImageCompressionFlagBitsEXT {
10112    type Output = Self;
10113    #[inline]
10114    fn bitxor(self, rhs: Self) -> Self {
10115        Self(self.0 ^ rhs.0)
10116    }
10117}
10118impl core::ops::BitXorAssign for ImageCompressionFlagBitsEXT {
10119    #[inline]
10120    fn bitxor_assign(&mut self, rhs: Self) {
10121        self.0 ^= rhs.0;
10122    }
10123}
10124impl core::ops::Not for ImageCompressionFlagBitsEXT {
10125    type Output = Self;
10126    #[inline]
10127    fn not(self) -> Self {
10128        Self(!self.0)
10129    }
10130}
10131impl core::fmt::Debug for ImageCompressionFlagBitsEXT {
10132    #[allow(unused_mut, unused_variables)]
10133    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10134        let mut first = true;
10135        let mut remaining = self.0;
10136        if remaining & Self::FIXED_RATE_DEFAULT.0 != 0 {
10137            if !first {
10138                f.write_str(" | ")?;
10139            }
10140            f.write_str("FIXED_RATE_DEFAULT")?;
10141            remaining &= !Self::FIXED_RATE_DEFAULT.0;
10142            first = false;
10143        }
10144        if remaining & Self::FIXED_RATE_EXPLICIT.0 != 0 {
10145            if !first {
10146                f.write_str(" | ")?;
10147            }
10148            f.write_str("FIXED_RATE_EXPLICIT")?;
10149            remaining &= !Self::FIXED_RATE_EXPLICIT.0;
10150            first = false;
10151        }
10152        if remaining & Self::DISABLED.0 != 0 {
10153            if !first {
10154                f.write_str(" | ")?;
10155            }
10156            f.write_str("DISABLED")?;
10157            remaining &= !Self::DISABLED.0;
10158            first = false;
10159        }
10160        if remaining != 0u32 {
10161            if !first {
10162                f.write_str(" | ")?;
10163            }
10164            write!(f, "{:#x}", remaining)?;
10165        } else if first {
10166            f.write_str("(empty)")?;
10167        }
10168        Ok(())
10169    }
10170}
10171///[`VkImageConstraintsInfoFlagBitsFUCHSIA`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html)
10172#[repr(transparent)]
10173#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
10174#[doc(alias = "VkImageConstraintsInfoFlagBitsFUCHSIA")]
10175pub struct ImageConstraintsInfoFlagBitsFUCHSIA(u32);
10176impl ImageConstraintsInfoFlagBitsFUCHSIA {
10177    #[inline]
10178    pub const fn empty() -> Self {
10179        Self(0u32)
10180    }
10181    #[inline]
10182    pub const fn from_raw(value: u32) -> Self {
10183        Self(value)
10184    }
10185    #[inline]
10186    pub const fn as_raw(self) -> u32 {
10187        self.0
10188    }
10189    #[inline]
10190    pub const fn is_empty(self) -> bool {
10191        self.0 == 0u32
10192    }
10193    #[inline]
10194    pub const fn contains(self, other: Self) -> bool {
10195        (self.0 & other.0) == other.0
10196    }
10197    ///Bit 0.
10198    pub const CPU_READ_RARELY: Self = Self(1u32);
10199    ///Bit 1.
10200    pub const CPU_READ_OFTEN: Self = Self(2u32);
10201    ///Bit 2.
10202    pub const CPU_WRITE_RARELY: Self = Self(4u32);
10203    ///Bit 3.
10204    pub const CPU_WRITE_OFTEN: Self = Self(8u32);
10205    ///Bit 4.
10206    pub const PROTECTED_OPTIONAL: Self = Self(16u32);
10207}
10208impl core::ops::BitOr for ImageConstraintsInfoFlagBitsFUCHSIA {
10209    type Output = Self;
10210    #[inline]
10211    fn bitor(self, rhs: Self) -> Self {
10212        Self(self.0 | rhs.0)
10213    }
10214}
10215impl core::ops::BitOrAssign for ImageConstraintsInfoFlagBitsFUCHSIA {
10216    #[inline]
10217    fn bitor_assign(&mut self, rhs: Self) {
10218        self.0 |= rhs.0;
10219    }
10220}
10221impl core::ops::BitAnd for ImageConstraintsInfoFlagBitsFUCHSIA {
10222    type Output = Self;
10223    #[inline]
10224    fn bitand(self, rhs: Self) -> Self {
10225        Self(self.0 & rhs.0)
10226    }
10227}
10228impl core::ops::BitAndAssign for ImageConstraintsInfoFlagBitsFUCHSIA {
10229    #[inline]
10230    fn bitand_assign(&mut self, rhs: Self) {
10231        self.0 &= rhs.0;
10232    }
10233}
10234impl core::ops::BitXor for ImageConstraintsInfoFlagBitsFUCHSIA {
10235    type Output = Self;
10236    #[inline]
10237    fn bitxor(self, rhs: Self) -> Self {
10238        Self(self.0 ^ rhs.0)
10239    }
10240}
10241impl core::ops::BitXorAssign for ImageConstraintsInfoFlagBitsFUCHSIA {
10242    #[inline]
10243    fn bitxor_assign(&mut self, rhs: Self) {
10244        self.0 ^= rhs.0;
10245    }
10246}
10247impl core::ops::Not for ImageConstraintsInfoFlagBitsFUCHSIA {
10248    type Output = Self;
10249    #[inline]
10250    fn not(self) -> Self {
10251        Self(!self.0)
10252    }
10253}
10254impl core::fmt::Debug for ImageConstraintsInfoFlagBitsFUCHSIA {
10255    #[allow(unused_mut, unused_variables)]
10256    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10257        let mut first = true;
10258        let mut remaining = self.0;
10259        if remaining & Self::CPU_READ_RARELY.0 != 0 {
10260            if !first {
10261                f.write_str(" | ")?;
10262            }
10263            f.write_str("CPU_READ_RARELY")?;
10264            remaining &= !Self::CPU_READ_RARELY.0;
10265            first = false;
10266        }
10267        if remaining & Self::CPU_READ_OFTEN.0 != 0 {
10268            if !first {
10269                f.write_str(" | ")?;
10270            }
10271            f.write_str("CPU_READ_OFTEN")?;
10272            remaining &= !Self::CPU_READ_OFTEN.0;
10273            first = false;
10274        }
10275        if remaining & Self::CPU_WRITE_RARELY.0 != 0 {
10276            if !first {
10277                f.write_str(" | ")?;
10278            }
10279            f.write_str("CPU_WRITE_RARELY")?;
10280            remaining &= !Self::CPU_WRITE_RARELY.0;
10281            first = false;
10282        }
10283        if remaining & Self::CPU_WRITE_OFTEN.0 != 0 {
10284            if !first {
10285                f.write_str(" | ")?;
10286            }
10287            f.write_str("CPU_WRITE_OFTEN")?;
10288            remaining &= !Self::CPU_WRITE_OFTEN.0;
10289            first = false;
10290        }
10291        if remaining & Self::PROTECTED_OPTIONAL.0 != 0 {
10292            if !first {
10293                f.write_str(" | ")?;
10294            }
10295            f.write_str("PROTECTED_OPTIONAL")?;
10296            remaining &= !Self::PROTECTED_OPTIONAL.0;
10297            first = false;
10298        }
10299        if remaining != 0u32 {
10300            if !first {
10301                f.write_str(" | ")?;
10302            }
10303            write!(f, "{:#x}", remaining)?;
10304        } else if first {
10305            f.write_str("(empty)")?;
10306        }
10307        Ok(())
10308    }
10309}
10310///[`VkImageCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlagBits.html)
10311#[repr(transparent)]
10312#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
10313#[doc(alias = "VkImageCreateFlagBits")]
10314pub struct ImageCreateFlagBits(u32);
10315impl ImageCreateFlagBits {
10316    #[inline]
10317    pub const fn empty() -> Self {
10318        Self(0u32)
10319    }
10320    #[inline]
10321    pub const fn from_raw(value: u32) -> Self {
10322        Self(value)
10323    }
10324    #[inline]
10325    pub const fn as_raw(self) -> u32 {
10326        self.0
10327    }
10328    #[inline]
10329    pub const fn is_empty(self) -> bool {
10330        self.0 == 0u32
10331    }
10332    #[inline]
10333    pub const fn contains(self, other: Self) -> bool {
10334        (self.0 & other.0) == other.0
10335    }
10336    ///Bit 0.
10337    pub const SPARSE_BINDING: Self = Self(1u32);
10338    ///Bit 1.
10339    pub const SPARSE_RESIDENCY: Self = Self(2u32);
10340    ///Bit 2.
10341    pub const SPARSE_ALIASED: Self = Self(4u32);
10342    ///Bit 3.
10343    pub const MUTABLE_FORMAT: Self = Self(8u32);
10344    ///Bit 4.
10345    pub const CUBE_COMPATIBLE: Self = Self(16u32);
10346    ///Bit 10.
10347    pub const ALIAS: Self = Self(1024u32);
10348    ///Bit 6.
10349    pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(64u32);
10350    ///Bit 5.
10351    pub const _2D_ARRAY_COMPATIBLE: Self = Self(32u32);
10352    ///Bit 7.
10353    pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = Self(128u32);
10354    ///Bit 8.
10355    pub const EXTENDED_USAGE: Self = Self(256u32);
10356    ///Bit 11.
10357    pub const PROTECTED: Self = Self(2048u32);
10358    ///Bit 9.
10359    pub const DISJOINT: Self = Self(512u32);
10360    ///Bit 13.
10361    pub const CORNER_SAMPLED: Self = Self(8192u32);
10362    ///Bit 16.
10363    pub const DESCRIPTOR_HEAP_CAPTURE_REPLAY: Self = Self(65536u32);
10364    ///Bit 12.
10365    pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH: Self = Self(4096u32);
10366    ///Bit 14.
10367    pub const SUBSAMPLED: Self = Self(16384u32);
10368    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY;
10369    ///Bit 18.
10370    pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED: Self = Self(262144u32);
10371    ///Bit 17.
10372    pub const _2D_VIEW_COMPATIBLE: Self = Self(131072u32);
10373    pub const FRAGMENT_DENSITY_MAP_OFFSET_BIT: Self = Self::FRAGMENT_DENSITY_MAP_OFFSET;
10374    ///Bit 20.
10375    pub const VIDEO_PROFILE_INDEPENDENT: Self = Self(1048576u32);
10376    ///Bit 15.
10377    pub const FRAGMENT_DENSITY_MAP_OFFSET: Self = Self(32768u32);
10378}
10379impl core::ops::BitOr for ImageCreateFlagBits {
10380    type Output = Self;
10381    #[inline]
10382    fn bitor(self, rhs: Self) -> Self {
10383        Self(self.0 | rhs.0)
10384    }
10385}
10386impl core::ops::BitOrAssign for ImageCreateFlagBits {
10387    #[inline]
10388    fn bitor_assign(&mut self, rhs: Self) {
10389        self.0 |= rhs.0;
10390    }
10391}
10392impl core::ops::BitAnd for ImageCreateFlagBits {
10393    type Output = Self;
10394    #[inline]
10395    fn bitand(self, rhs: Self) -> Self {
10396        Self(self.0 & rhs.0)
10397    }
10398}
10399impl core::ops::BitAndAssign for ImageCreateFlagBits {
10400    #[inline]
10401    fn bitand_assign(&mut self, rhs: Self) {
10402        self.0 &= rhs.0;
10403    }
10404}
10405impl core::ops::BitXor for ImageCreateFlagBits {
10406    type Output = Self;
10407    #[inline]
10408    fn bitxor(self, rhs: Self) -> Self {
10409        Self(self.0 ^ rhs.0)
10410    }
10411}
10412impl core::ops::BitXorAssign for ImageCreateFlagBits {
10413    #[inline]
10414    fn bitxor_assign(&mut self, rhs: Self) {
10415        self.0 ^= rhs.0;
10416    }
10417}
10418impl core::ops::Not for ImageCreateFlagBits {
10419    type Output = Self;
10420    #[inline]
10421    fn not(self) -> Self {
10422        Self(!self.0)
10423    }
10424}
10425impl core::fmt::Debug for ImageCreateFlagBits {
10426    #[allow(unused_mut, unused_variables)]
10427    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10428        let mut first = true;
10429        let mut remaining = self.0;
10430        if remaining & Self::SPARSE_BINDING.0 != 0 {
10431            if !first {
10432                f.write_str(" | ")?;
10433            }
10434            f.write_str("SPARSE_BINDING")?;
10435            remaining &= !Self::SPARSE_BINDING.0;
10436            first = false;
10437        }
10438        if remaining & Self::SPARSE_RESIDENCY.0 != 0 {
10439            if !first {
10440                f.write_str(" | ")?;
10441            }
10442            f.write_str("SPARSE_RESIDENCY")?;
10443            remaining &= !Self::SPARSE_RESIDENCY.0;
10444            first = false;
10445        }
10446        if remaining & Self::SPARSE_ALIASED.0 != 0 {
10447            if !first {
10448                f.write_str(" | ")?;
10449            }
10450            f.write_str("SPARSE_ALIASED")?;
10451            remaining &= !Self::SPARSE_ALIASED.0;
10452            first = false;
10453        }
10454        if remaining & Self::MUTABLE_FORMAT.0 != 0 {
10455            if !first {
10456                f.write_str(" | ")?;
10457            }
10458            f.write_str("MUTABLE_FORMAT")?;
10459            remaining &= !Self::MUTABLE_FORMAT.0;
10460            first = false;
10461        }
10462        if remaining & Self::CUBE_COMPATIBLE.0 != 0 {
10463            if !first {
10464                f.write_str(" | ")?;
10465            }
10466            f.write_str("CUBE_COMPATIBLE")?;
10467            remaining &= !Self::CUBE_COMPATIBLE.0;
10468            first = false;
10469        }
10470        if remaining & Self::ALIAS.0 != 0 {
10471            if !first {
10472                f.write_str(" | ")?;
10473            }
10474            f.write_str("ALIAS")?;
10475            remaining &= !Self::ALIAS.0;
10476            first = false;
10477        }
10478        if remaining & Self::SPLIT_INSTANCE_BIND_REGIONS.0 != 0 {
10479            if !first {
10480                f.write_str(" | ")?;
10481            }
10482            f.write_str("SPLIT_INSTANCE_BIND_REGIONS")?;
10483            remaining &= !Self::SPLIT_INSTANCE_BIND_REGIONS.0;
10484            first = false;
10485        }
10486        if remaining & Self::_2D_ARRAY_COMPATIBLE.0 != 0 {
10487            if !first {
10488                f.write_str(" | ")?;
10489            }
10490            f.write_str("_2D_ARRAY_COMPATIBLE")?;
10491            remaining &= !Self::_2D_ARRAY_COMPATIBLE.0;
10492            first = false;
10493        }
10494        if remaining & Self::BLOCK_TEXEL_VIEW_COMPATIBLE.0 != 0 {
10495            if !first {
10496                f.write_str(" | ")?;
10497            }
10498            f.write_str("BLOCK_TEXEL_VIEW_COMPATIBLE")?;
10499            remaining &= !Self::BLOCK_TEXEL_VIEW_COMPATIBLE.0;
10500            first = false;
10501        }
10502        if remaining & Self::EXTENDED_USAGE.0 != 0 {
10503            if !first {
10504                f.write_str(" | ")?;
10505            }
10506            f.write_str("EXTENDED_USAGE")?;
10507            remaining &= !Self::EXTENDED_USAGE.0;
10508            first = false;
10509        }
10510        if remaining & Self::PROTECTED.0 != 0 {
10511            if !first {
10512                f.write_str(" | ")?;
10513            }
10514            f.write_str("PROTECTED")?;
10515            remaining &= !Self::PROTECTED.0;
10516            first = false;
10517        }
10518        if remaining & Self::DISJOINT.0 != 0 {
10519            if !first {
10520                f.write_str(" | ")?;
10521            }
10522            f.write_str("DISJOINT")?;
10523            remaining &= !Self::DISJOINT.0;
10524            first = false;
10525        }
10526        if remaining & Self::CORNER_SAMPLED.0 != 0 {
10527            if !first {
10528                f.write_str(" | ")?;
10529            }
10530            f.write_str("CORNER_SAMPLED")?;
10531            remaining &= !Self::CORNER_SAMPLED.0;
10532            first = false;
10533        }
10534        if remaining & Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY.0 != 0 {
10535            if !first {
10536                f.write_str(" | ")?;
10537            }
10538            f.write_str("DESCRIPTOR_HEAP_CAPTURE_REPLAY")?;
10539            remaining &= !Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY.0;
10540            first = false;
10541        }
10542        if remaining & Self::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH.0 != 0 {
10543            if !first {
10544                f.write_str(" | ")?;
10545            }
10546            f.write_str("SAMPLE_LOCATIONS_COMPATIBLE_DEPTH")?;
10547            remaining &= !Self::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH.0;
10548            first = false;
10549        }
10550        if remaining & Self::SUBSAMPLED.0 != 0 {
10551            if !first {
10552                f.write_str(" | ")?;
10553            }
10554            f.write_str("SUBSAMPLED")?;
10555            remaining &= !Self::SUBSAMPLED.0;
10556            first = false;
10557        }
10558        if remaining & Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED.0 != 0 {
10559            if !first {
10560                f.write_str(" | ")?;
10561            }
10562            f.write_str("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED")?;
10563            remaining &= !Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED.0;
10564            first = false;
10565        }
10566        if remaining & Self::_2D_VIEW_COMPATIBLE.0 != 0 {
10567            if !first {
10568                f.write_str(" | ")?;
10569            }
10570            f.write_str("_2D_VIEW_COMPATIBLE")?;
10571            remaining &= !Self::_2D_VIEW_COMPATIBLE.0;
10572            first = false;
10573        }
10574        if remaining & Self::VIDEO_PROFILE_INDEPENDENT.0 != 0 {
10575            if !first {
10576                f.write_str(" | ")?;
10577            }
10578            f.write_str("VIDEO_PROFILE_INDEPENDENT")?;
10579            remaining &= !Self::VIDEO_PROFILE_INDEPENDENT.0;
10580            first = false;
10581        }
10582        if remaining & Self::FRAGMENT_DENSITY_MAP_OFFSET.0 != 0 {
10583            if !first {
10584                f.write_str(" | ")?;
10585            }
10586            f.write_str("FRAGMENT_DENSITY_MAP_OFFSET")?;
10587            remaining &= !Self::FRAGMENT_DENSITY_MAP_OFFSET.0;
10588            first = false;
10589        }
10590        if remaining != 0u32 {
10591            if !first {
10592                f.write_str(" | ")?;
10593            }
10594            write!(f, "{:#x}", remaining)?;
10595        } else if first {
10596            f.write_str("(empty)")?;
10597        }
10598        Ok(())
10599    }
10600}
10601///[`VkImageFormatConstraintsFlagBitsFUCHSIA`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html)
10602#[repr(transparent)]
10603#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
10604#[doc(alias = "VkImageFormatConstraintsFlagBitsFUCHSIA")]
10605pub struct ImageFormatConstraintsFlagBitsFUCHSIA(u32);
10606impl ImageFormatConstraintsFlagBitsFUCHSIA {
10607    #[inline]
10608    pub const fn empty() -> Self {
10609        Self(0u32)
10610    }
10611    #[inline]
10612    pub const fn from_raw(value: u32) -> Self {
10613        Self(value)
10614    }
10615    #[inline]
10616    pub const fn as_raw(self) -> u32 {
10617        self.0
10618    }
10619    #[inline]
10620    pub const fn is_empty(self) -> bool {
10621        self.0 == 0u32
10622    }
10623    #[inline]
10624    pub const fn contains(self, other: Self) -> bool {
10625        (self.0 & other.0) == other.0
10626    }
10627}
10628impl core::ops::BitOr for ImageFormatConstraintsFlagBitsFUCHSIA {
10629    type Output = Self;
10630    #[inline]
10631    fn bitor(self, rhs: Self) -> Self {
10632        Self(self.0 | rhs.0)
10633    }
10634}
10635impl core::ops::BitOrAssign for ImageFormatConstraintsFlagBitsFUCHSIA {
10636    #[inline]
10637    fn bitor_assign(&mut self, rhs: Self) {
10638        self.0 |= rhs.0;
10639    }
10640}
10641impl core::ops::BitAnd for ImageFormatConstraintsFlagBitsFUCHSIA {
10642    type Output = Self;
10643    #[inline]
10644    fn bitand(self, rhs: Self) -> Self {
10645        Self(self.0 & rhs.0)
10646    }
10647}
10648impl core::ops::BitAndAssign for ImageFormatConstraintsFlagBitsFUCHSIA {
10649    #[inline]
10650    fn bitand_assign(&mut self, rhs: Self) {
10651        self.0 &= rhs.0;
10652    }
10653}
10654impl core::ops::BitXor for ImageFormatConstraintsFlagBitsFUCHSIA {
10655    type Output = Self;
10656    #[inline]
10657    fn bitxor(self, rhs: Self) -> Self {
10658        Self(self.0 ^ rhs.0)
10659    }
10660}
10661impl core::ops::BitXorAssign for ImageFormatConstraintsFlagBitsFUCHSIA {
10662    #[inline]
10663    fn bitxor_assign(&mut self, rhs: Self) {
10664        self.0 ^= rhs.0;
10665    }
10666}
10667impl core::ops::Not for ImageFormatConstraintsFlagBitsFUCHSIA {
10668    type Output = Self;
10669    #[inline]
10670    fn not(self) -> Self {
10671        Self(!self.0)
10672    }
10673}
10674impl core::fmt::Debug for ImageFormatConstraintsFlagBitsFUCHSIA {
10675    #[allow(unused_mut, unused_variables)]
10676    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10677        let mut first = true;
10678        let mut remaining = self.0;
10679        if remaining != 0u32 {
10680            if !first {
10681                f.write_str(" | ")?;
10682            }
10683            write!(f, "{:#x}", remaining)?;
10684        } else if first {
10685            f.write_str("(empty)")?;
10686        }
10687        Ok(())
10688    }
10689}
10690///[`VkImageUsageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageUsageFlagBits.html)
10691#[repr(transparent)]
10692#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
10693#[doc(alias = "VkImageUsageFlagBits")]
10694pub struct ImageUsageFlagBits(u32);
10695impl ImageUsageFlagBits {
10696    #[inline]
10697    pub const fn empty() -> Self {
10698        Self(0u32)
10699    }
10700    #[inline]
10701    pub const fn from_raw(value: u32) -> Self {
10702        Self(value)
10703    }
10704    #[inline]
10705    pub const fn as_raw(self) -> u32 {
10706        self.0
10707    }
10708    #[inline]
10709    pub const fn is_empty(self) -> bool {
10710        self.0 == 0u32
10711    }
10712    #[inline]
10713    pub const fn contains(self, other: Self) -> bool {
10714        (self.0 & other.0) == other.0
10715    }
10716    ///Bit 0.
10717    pub const TRANSFER_SRC: Self = Self(1u32);
10718    ///Bit 1.
10719    pub const TRANSFER_DST: Self = Self(2u32);
10720    ///Bit 2.
10721    pub const SAMPLED: Self = Self(4u32);
10722    ///Bit 3.
10723    pub const STORAGE: Self = Self(8u32);
10724    ///Bit 4.
10725    pub const COLOR_ATTACHMENT: Self = Self(16u32);
10726    ///Bit 5.
10727    pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(32u32);
10728    ///Bit 6.
10729    pub const TRANSIENT_ATTACHMENT: Self = Self(64u32);
10730    ///Bit 7.
10731    pub const INPUT_ATTACHMENT: Self = Self(128u32);
10732    ///Bit 22.
10733    pub const HOST_TRANSFER: Self = Self(4194304u32);
10734    ///Bit 10.
10735    pub const VIDEO_DECODE_DST: Self = Self(1024u32);
10736    ///Bit 11.
10737    pub const VIDEO_DECODE_SRC: Self = Self(2048u32);
10738    ///Bit 12.
10739    pub const VIDEO_DECODE_DPB: Self = Self(4096u32);
10740    pub const SHADING_RATE_IMAGE: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT;
10741    ///Bit 9.
10742    pub const FRAGMENT_DENSITY_MAP: Self = Self(512u32);
10743    ///Bit 8.
10744    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(256u32);
10745    ///Bit 13.
10746    pub const VIDEO_ENCODE_DST: Self = Self(8192u32);
10747    ///Bit 14.
10748    pub const VIDEO_ENCODE_SRC: Self = Self(16384u32);
10749    ///Bit 15.
10750    pub const VIDEO_ENCODE_DPB: Self = Self(32768u32);
10751    ///Bit 19.
10752    pub const ATTACHMENT_FEEDBACK_LOOP: Self = Self(524288u32);
10753    ///Bit 18.
10754    pub const INVOCATION_MASK_BIT: Self = Self(262144u32);
10755    ///Bit 20.
10756    pub const SAMPLE_WEIGHT_BIT: Self = Self(1048576u32);
10757    ///Bit 21.
10758    pub const SAMPLE_BLOCK_MATCH_BIT: Self = Self(2097152u32);
10759    ///Bit 23.
10760    pub const TENSOR_ALIASING_BIT: Self = Self(8388608u32);
10761    ///Bit 27.
10762    pub const TILE_MEMORY_BIT: Self = Self(134217728u32);
10763    ///Bit 25.
10764    pub const VIDEO_ENCODE_QUANTIZATION_DELTA_MAP: Self = Self(33554432u32);
10765    ///Bit 26.
10766    pub const VIDEO_ENCODE_EMPHASIS_MAP: Self = Self(67108864u32);
10767}
10768impl core::ops::BitOr for ImageUsageFlagBits {
10769    type Output = Self;
10770    #[inline]
10771    fn bitor(self, rhs: Self) -> Self {
10772        Self(self.0 | rhs.0)
10773    }
10774}
10775impl core::ops::BitOrAssign for ImageUsageFlagBits {
10776    #[inline]
10777    fn bitor_assign(&mut self, rhs: Self) {
10778        self.0 |= rhs.0;
10779    }
10780}
10781impl core::ops::BitAnd for ImageUsageFlagBits {
10782    type Output = Self;
10783    #[inline]
10784    fn bitand(self, rhs: Self) -> Self {
10785        Self(self.0 & rhs.0)
10786    }
10787}
10788impl core::ops::BitAndAssign for ImageUsageFlagBits {
10789    #[inline]
10790    fn bitand_assign(&mut self, rhs: Self) {
10791        self.0 &= rhs.0;
10792    }
10793}
10794impl core::ops::BitXor for ImageUsageFlagBits {
10795    type Output = Self;
10796    #[inline]
10797    fn bitxor(self, rhs: Self) -> Self {
10798        Self(self.0 ^ rhs.0)
10799    }
10800}
10801impl core::ops::BitXorAssign for ImageUsageFlagBits {
10802    #[inline]
10803    fn bitxor_assign(&mut self, rhs: Self) {
10804        self.0 ^= rhs.0;
10805    }
10806}
10807impl core::ops::Not for ImageUsageFlagBits {
10808    type Output = Self;
10809    #[inline]
10810    fn not(self) -> Self {
10811        Self(!self.0)
10812    }
10813}
10814impl core::fmt::Debug for ImageUsageFlagBits {
10815    #[allow(unused_mut, unused_variables)]
10816    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10817        let mut first = true;
10818        let mut remaining = self.0;
10819        if remaining & Self::TRANSFER_SRC.0 != 0 {
10820            if !first {
10821                f.write_str(" | ")?;
10822            }
10823            f.write_str("TRANSFER_SRC")?;
10824            remaining &= !Self::TRANSFER_SRC.0;
10825            first = false;
10826        }
10827        if remaining & Self::TRANSFER_DST.0 != 0 {
10828            if !first {
10829                f.write_str(" | ")?;
10830            }
10831            f.write_str("TRANSFER_DST")?;
10832            remaining &= !Self::TRANSFER_DST.0;
10833            first = false;
10834        }
10835        if remaining & Self::SAMPLED.0 != 0 {
10836            if !first {
10837                f.write_str(" | ")?;
10838            }
10839            f.write_str("SAMPLED")?;
10840            remaining &= !Self::SAMPLED.0;
10841            first = false;
10842        }
10843        if remaining & Self::STORAGE.0 != 0 {
10844            if !first {
10845                f.write_str(" | ")?;
10846            }
10847            f.write_str("STORAGE")?;
10848            remaining &= !Self::STORAGE.0;
10849            first = false;
10850        }
10851        if remaining & Self::COLOR_ATTACHMENT.0 != 0 {
10852            if !first {
10853                f.write_str(" | ")?;
10854            }
10855            f.write_str("COLOR_ATTACHMENT")?;
10856            remaining &= !Self::COLOR_ATTACHMENT.0;
10857            first = false;
10858        }
10859        if remaining & Self::DEPTH_STENCIL_ATTACHMENT.0 != 0 {
10860            if !first {
10861                f.write_str(" | ")?;
10862            }
10863            f.write_str("DEPTH_STENCIL_ATTACHMENT")?;
10864            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT.0;
10865            first = false;
10866        }
10867        if remaining & Self::TRANSIENT_ATTACHMENT.0 != 0 {
10868            if !first {
10869                f.write_str(" | ")?;
10870            }
10871            f.write_str("TRANSIENT_ATTACHMENT")?;
10872            remaining &= !Self::TRANSIENT_ATTACHMENT.0;
10873            first = false;
10874        }
10875        if remaining & Self::INPUT_ATTACHMENT.0 != 0 {
10876            if !first {
10877                f.write_str(" | ")?;
10878            }
10879            f.write_str("INPUT_ATTACHMENT")?;
10880            remaining &= !Self::INPUT_ATTACHMENT.0;
10881            first = false;
10882        }
10883        if remaining & Self::HOST_TRANSFER.0 != 0 {
10884            if !first {
10885                f.write_str(" | ")?;
10886            }
10887            f.write_str("HOST_TRANSFER")?;
10888            remaining &= !Self::HOST_TRANSFER.0;
10889            first = false;
10890        }
10891        if remaining & Self::VIDEO_DECODE_DST.0 != 0 {
10892            if !first {
10893                f.write_str(" | ")?;
10894            }
10895            f.write_str("VIDEO_DECODE_DST")?;
10896            remaining &= !Self::VIDEO_DECODE_DST.0;
10897            first = false;
10898        }
10899        if remaining & Self::VIDEO_DECODE_SRC.0 != 0 {
10900            if !first {
10901                f.write_str(" | ")?;
10902            }
10903            f.write_str("VIDEO_DECODE_SRC")?;
10904            remaining &= !Self::VIDEO_DECODE_SRC.0;
10905            first = false;
10906        }
10907        if remaining & Self::VIDEO_DECODE_DPB.0 != 0 {
10908            if !first {
10909                f.write_str(" | ")?;
10910            }
10911            f.write_str("VIDEO_DECODE_DPB")?;
10912            remaining &= !Self::VIDEO_DECODE_DPB.0;
10913            first = false;
10914        }
10915        if remaining & Self::FRAGMENT_DENSITY_MAP.0 != 0 {
10916            if !first {
10917                f.write_str(" | ")?;
10918            }
10919            f.write_str("FRAGMENT_DENSITY_MAP")?;
10920            remaining &= !Self::FRAGMENT_DENSITY_MAP.0;
10921            first = false;
10922        }
10923        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
10924            if !first {
10925                f.write_str(" | ")?;
10926            }
10927            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT")?;
10928            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0;
10929            first = false;
10930        }
10931        if remaining & Self::VIDEO_ENCODE_DST.0 != 0 {
10932            if !first {
10933                f.write_str(" | ")?;
10934            }
10935            f.write_str("VIDEO_ENCODE_DST")?;
10936            remaining &= !Self::VIDEO_ENCODE_DST.0;
10937            first = false;
10938        }
10939        if remaining & Self::VIDEO_ENCODE_SRC.0 != 0 {
10940            if !first {
10941                f.write_str(" | ")?;
10942            }
10943            f.write_str("VIDEO_ENCODE_SRC")?;
10944            remaining &= !Self::VIDEO_ENCODE_SRC.0;
10945            first = false;
10946        }
10947        if remaining & Self::VIDEO_ENCODE_DPB.0 != 0 {
10948            if !first {
10949                f.write_str(" | ")?;
10950            }
10951            f.write_str("VIDEO_ENCODE_DPB")?;
10952            remaining &= !Self::VIDEO_ENCODE_DPB.0;
10953            first = false;
10954        }
10955        if remaining & Self::ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
10956            if !first {
10957                f.write_str(" | ")?;
10958            }
10959            f.write_str("ATTACHMENT_FEEDBACK_LOOP")?;
10960            remaining &= !Self::ATTACHMENT_FEEDBACK_LOOP.0;
10961            first = false;
10962        }
10963        if remaining & Self::INVOCATION_MASK_BIT.0 != 0 {
10964            if !first {
10965                f.write_str(" | ")?;
10966            }
10967            f.write_str("INVOCATION_MASK_BIT")?;
10968            remaining &= !Self::INVOCATION_MASK_BIT.0;
10969            first = false;
10970        }
10971        if remaining & Self::SAMPLE_WEIGHT_BIT.0 != 0 {
10972            if !first {
10973                f.write_str(" | ")?;
10974            }
10975            f.write_str("SAMPLE_WEIGHT_BIT")?;
10976            remaining &= !Self::SAMPLE_WEIGHT_BIT.0;
10977            first = false;
10978        }
10979        if remaining & Self::SAMPLE_BLOCK_MATCH_BIT.0 != 0 {
10980            if !first {
10981                f.write_str(" | ")?;
10982            }
10983            f.write_str("SAMPLE_BLOCK_MATCH_BIT")?;
10984            remaining &= !Self::SAMPLE_BLOCK_MATCH_BIT.0;
10985            first = false;
10986        }
10987        if remaining & Self::TENSOR_ALIASING_BIT.0 != 0 {
10988            if !first {
10989                f.write_str(" | ")?;
10990            }
10991            f.write_str("TENSOR_ALIASING_BIT")?;
10992            remaining &= !Self::TENSOR_ALIASING_BIT.0;
10993            first = false;
10994        }
10995        if remaining & Self::TILE_MEMORY_BIT.0 != 0 {
10996            if !first {
10997                f.write_str(" | ")?;
10998            }
10999            f.write_str("TILE_MEMORY_BIT")?;
11000            remaining &= !Self::TILE_MEMORY_BIT.0;
11001            first = false;
11002        }
11003        if remaining & Self::VIDEO_ENCODE_QUANTIZATION_DELTA_MAP.0 != 0 {
11004            if !first {
11005                f.write_str(" | ")?;
11006            }
11007            f.write_str("VIDEO_ENCODE_QUANTIZATION_DELTA_MAP")?;
11008            remaining &= !Self::VIDEO_ENCODE_QUANTIZATION_DELTA_MAP.0;
11009            first = false;
11010        }
11011        if remaining & Self::VIDEO_ENCODE_EMPHASIS_MAP.0 != 0 {
11012            if !first {
11013                f.write_str(" | ")?;
11014            }
11015            f.write_str("VIDEO_ENCODE_EMPHASIS_MAP")?;
11016            remaining &= !Self::VIDEO_ENCODE_EMPHASIS_MAP.0;
11017            first = false;
11018        }
11019        if remaining != 0u32 {
11020            if !first {
11021                f.write_str(" | ")?;
11022            }
11023            write!(f, "{:#x}", remaining)?;
11024        } else if first {
11025            f.write_str("(empty)")?;
11026        }
11027        Ok(())
11028    }
11029}
11030///[`VkImageViewCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCreateFlagBits.html)
11031#[repr(transparent)]
11032#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11033#[doc(alias = "VkImageViewCreateFlagBits")]
11034pub struct ImageViewCreateFlagBits(u32);
11035impl ImageViewCreateFlagBits {
11036    #[inline]
11037    pub const fn empty() -> Self {
11038        Self(0u32)
11039    }
11040    #[inline]
11041    pub const fn from_raw(value: u32) -> Self {
11042        Self(value)
11043    }
11044    #[inline]
11045    pub const fn as_raw(self) -> u32 {
11046        self.0
11047    }
11048    #[inline]
11049    pub const fn is_empty(self) -> bool {
11050        self.0 == 0u32
11051    }
11052    #[inline]
11053    pub const fn contains(self, other: Self) -> bool {
11054        (self.0 & other.0) == other.0
11055    }
11056    ///Bit 0.
11057    pub const FRAGMENT_DENSITY_MAP_DYNAMIC: Self = Self(1u32);
11058    ///Bit 2.
11059    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self(4u32);
11060    ///Bit 1.
11061    pub const FRAGMENT_DENSITY_MAP_DEFERRED: Self = Self(2u32);
11062}
11063impl core::ops::BitOr for ImageViewCreateFlagBits {
11064    type Output = Self;
11065    #[inline]
11066    fn bitor(self, rhs: Self) -> Self {
11067        Self(self.0 | rhs.0)
11068    }
11069}
11070impl core::ops::BitOrAssign for ImageViewCreateFlagBits {
11071    #[inline]
11072    fn bitor_assign(&mut self, rhs: Self) {
11073        self.0 |= rhs.0;
11074    }
11075}
11076impl core::ops::BitAnd for ImageViewCreateFlagBits {
11077    type Output = Self;
11078    #[inline]
11079    fn bitand(self, rhs: Self) -> Self {
11080        Self(self.0 & rhs.0)
11081    }
11082}
11083impl core::ops::BitAndAssign for ImageViewCreateFlagBits {
11084    #[inline]
11085    fn bitand_assign(&mut self, rhs: Self) {
11086        self.0 &= rhs.0;
11087    }
11088}
11089impl core::ops::BitXor for ImageViewCreateFlagBits {
11090    type Output = Self;
11091    #[inline]
11092    fn bitxor(self, rhs: Self) -> Self {
11093        Self(self.0 ^ rhs.0)
11094    }
11095}
11096impl core::ops::BitXorAssign for ImageViewCreateFlagBits {
11097    #[inline]
11098    fn bitxor_assign(&mut self, rhs: Self) {
11099        self.0 ^= rhs.0;
11100    }
11101}
11102impl core::ops::Not for ImageViewCreateFlagBits {
11103    type Output = Self;
11104    #[inline]
11105    fn not(self) -> Self {
11106        Self(!self.0)
11107    }
11108}
11109impl core::fmt::Debug for ImageViewCreateFlagBits {
11110    #[allow(unused_mut, unused_variables)]
11111    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11112        let mut first = true;
11113        let mut remaining = self.0;
11114        if remaining & Self::FRAGMENT_DENSITY_MAP_DYNAMIC.0 != 0 {
11115            if !first {
11116                f.write_str(" | ")?;
11117            }
11118            f.write_str("FRAGMENT_DENSITY_MAP_DYNAMIC")?;
11119            remaining &= !Self::FRAGMENT_DENSITY_MAP_DYNAMIC.0;
11120            first = false;
11121        }
11122        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0 != 0 {
11123            if !first {
11124                f.write_str(" | ")?;
11125            }
11126            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY")?;
11127            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0;
11128            first = false;
11129        }
11130        if remaining & Self::FRAGMENT_DENSITY_MAP_DEFERRED.0 != 0 {
11131            if !first {
11132                f.write_str(" | ")?;
11133            }
11134            f.write_str("FRAGMENT_DENSITY_MAP_DEFERRED")?;
11135            remaining &= !Self::FRAGMENT_DENSITY_MAP_DEFERRED.0;
11136            first = false;
11137        }
11138        if remaining != 0u32 {
11139            if !first {
11140                f.write_str(" | ")?;
11141            }
11142            write!(f, "{:#x}", remaining)?;
11143        } else if first {
11144            f.write_str("(empty)")?;
11145        }
11146        Ok(())
11147    }
11148}
11149///[`VkIndirectCommandsInputModeFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsInputModeFlagBitsEXT.html)
11150#[repr(transparent)]
11151#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11152#[doc(alias = "VkIndirectCommandsInputModeFlagBitsEXT")]
11153pub struct IndirectCommandsInputModeFlagBitsEXT(u32);
11154impl IndirectCommandsInputModeFlagBitsEXT {
11155    #[inline]
11156    pub const fn empty() -> Self {
11157        Self(0u32)
11158    }
11159    #[inline]
11160    pub const fn from_raw(value: u32) -> Self {
11161        Self(value)
11162    }
11163    #[inline]
11164    pub const fn as_raw(self) -> u32 {
11165        self.0
11166    }
11167    #[inline]
11168    pub const fn is_empty(self) -> bool {
11169        self.0 == 0u32
11170    }
11171    #[inline]
11172    pub const fn contains(self, other: Self) -> bool {
11173        (self.0 & other.0) == other.0
11174    }
11175    ///Bit 0.
11176    pub const VULKAN_INDEX_BUFFER: Self = Self(1u32);
11177    ///Bit 1.
11178    pub const DXGI_INDEX_BUFFER: Self = Self(2u32);
11179}
11180impl core::ops::BitOr for IndirectCommandsInputModeFlagBitsEXT {
11181    type Output = Self;
11182    #[inline]
11183    fn bitor(self, rhs: Self) -> Self {
11184        Self(self.0 | rhs.0)
11185    }
11186}
11187impl core::ops::BitOrAssign for IndirectCommandsInputModeFlagBitsEXT {
11188    #[inline]
11189    fn bitor_assign(&mut self, rhs: Self) {
11190        self.0 |= rhs.0;
11191    }
11192}
11193impl core::ops::BitAnd for IndirectCommandsInputModeFlagBitsEXT {
11194    type Output = Self;
11195    #[inline]
11196    fn bitand(self, rhs: Self) -> Self {
11197        Self(self.0 & rhs.0)
11198    }
11199}
11200impl core::ops::BitAndAssign for IndirectCommandsInputModeFlagBitsEXT {
11201    #[inline]
11202    fn bitand_assign(&mut self, rhs: Self) {
11203        self.0 &= rhs.0;
11204    }
11205}
11206impl core::ops::BitXor for IndirectCommandsInputModeFlagBitsEXT {
11207    type Output = Self;
11208    #[inline]
11209    fn bitxor(self, rhs: Self) -> Self {
11210        Self(self.0 ^ rhs.0)
11211    }
11212}
11213impl core::ops::BitXorAssign for IndirectCommandsInputModeFlagBitsEXT {
11214    #[inline]
11215    fn bitxor_assign(&mut self, rhs: Self) {
11216        self.0 ^= rhs.0;
11217    }
11218}
11219impl core::ops::Not for IndirectCommandsInputModeFlagBitsEXT {
11220    type Output = Self;
11221    #[inline]
11222    fn not(self) -> Self {
11223        Self(!self.0)
11224    }
11225}
11226impl core::fmt::Debug for IndirectCommandsInputModeFlagBitsEXT {
11227    #[allow(unused_mut, unused_variables)]
11228    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11229        let mut first = true;
11230        let mut remaining = self.0;
11231        if remaining & Self::VULKAN_INDEX_BUFFER.0 != 0 {
11232            if !first {
11233                f.write_str(" | ")?;
11234            }
11235            f.write_str("VULKAN_INDEX_BUFFER")?;
11236            remaining &= !Self::VULKAN_INDEX_BUFFER.0;
11237            first = false;
11238        }
11239        if remaining & Self::DXGI_INDEX_BUFFER.0 != 0 {
11240            if !first {
11241                f.write_str(" | ")?;
11242            }
11243            f.write_str("DXGI_INDEX_BUFFER")?;
11244            remaining &= !Self::DXGI_INDEX_BUFFER.0;
11245            first = false;
11246        }
11247        if remaining != 0u32 {
11248            if !first {
11249                f.write_str(" | ")?;
11250            }
11251            write!(f, "{:#x}", remaining)?;
11252        } else if first {
11253            f.write_str("(empty)")?;
11254        }
11255        Ok(())
11256    }
11257}
11258///[`VkIndirectCommandsLayoutUsageFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagBitsEXT.html)
11259#[repr(transparent)]
11260#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11261#[doc(alias = "VkIndirectCommandsLayoutUsageFlagBitsEXT")]
11262pub struct IndirectCommandsLayoutUsageFlagBitsEXT(u32);
11263impl IndirectCommandsLayoutUsageFlagBitsEXT {
11264    #[inline]
11265    pub const fn empty() -> Self {
11266        Self(0u32)
11267    }
11268    #[inline]
11269    pub const fn from_raw(value: u32) -> Self {
11270        Self(value)
11271    }
11272    #[inline]
11273    pub const fn as_raw(self) -> u32 {
11274        self.0
11275    }
11276    #[inline]
11277    pub const fn is_empty(self) -> bool {
11278        self.0 == 0u32
11279    }
11280    #[inline]
11281    pub const fn contains(self, other: Self) -> bool {
11282        (self.0 & other.0) == other.0
11283    }
11284    ///Bit 0.
11285    pub const EXPLICIT_PREPROCESS: Self = Self(1u32);
11286    ///Bit 1.
11287    pub const UNORDERED_SEQUENCES: Self = Self(2u32);
11288}
11289impl core::ops::BitOr for IndirectCommandsLayoutUsageFlagBitsEXT {
11290    type Output = Self;
11291    #[inline]
11292    fn bitor(self, rhs: Self) -> Self {
11293        Self(self.0 | rhs.0)
11294    }
11295}
11296impl core::ops::BitOrAssign for IndirectCommandsLayoutUsageFlagBitsEXT {
11297    #[inline]
11298    fn bitor_assign(&mut self, rhs: Self) {
11299        self.0 |= rhs.0;
11300    }
11301}
11302impl core::ops::BitAnd for IndirectCommandsLayoutUsageFlagBitsEXT {
11303    type Output = Self;
11304    #[inline]
11305    fn bitand(self, rhs: Self) -> Self {
11306        Self(self.0 & rhs.0)
11307    }
11308}
11309impl core::ops::BitAndAssign for IndirectCommandsLayoutUsageFlagBitsEXT {
11310    #[inline]
11311    fn bitand_assign(&mut self, rhs: Self) {
11312        self.0 &= rhs.0;
11313    }
11314}
11315impl core::ops::BitXor for IndirectCommandsLayoutUsageFlagBitsEXT {
11316    type Output = Self;
11317    #[inline]
11318    fn bitxor(self, rhs: Self) -> Self {
11319        Self(self.0 ^ rhs.0)
11320    }
11321}
11322impl core::ops::BitXorAssign for IndirectCommandsLayoutUsageFlagBitsEXT {
11323    #[inline]
11324    fn bitxor_assign(&mut self, rhs: Self) {
11325        self.0 ^= rhs.0;
11326    }
11327}
11328impl core::ops::Not for IndirectCommandsLayoutUsageFlagBitsEXT {
11329    type Output = Self;
11330    #[inline]
11331    fn not(self) -> Self {
11332        Self(!self.0)
11333    }
11334}
11335impl core::fmt::Debug for IndirectCommandsLayoutUsageFlagBitsEXT {
11336    #[allow(unused_mut, unused_variables)]
11337    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11338        let mut first = true;
11339        let mut remaining = self.0;
11340        if remaining & Self::EXPLICIT_PREPROCESS.0 != 0 {
11341            if !first {
11342                f.write_str(" | ")?;
11343            }
11344            f.write_str("EXPLICIT_PREPROCESS")?;
11345            remaining &= !Self::EXPLICIT_PREPROCESS.0;
11346            first = false;
11347        }
11348        if remaining & Self::UNORDERED_SEQUENCES.0 != 0 {
11349            if !first {
11350                f.write_str(" | ")?;
11351            }
11352            f.write_str("UNORDERED_SEQUENCES")?;
11353            remaining &= !Self::UNORDERED_SEQUENCES.0;
11354            first = false;
11355        }
11356        if remaining != 0u32 {
11357            if !first {
11358                f.write_str(" | ")?;
11359            }
11360            write!(f, "{:#x}", remaining)?;
11361        } else if first {
11362            f.write_str("(empty)")?;
11363        }
11364        Ok(())
11365    }
11366}
11367///[`VkIndirectCommandsLayoutUsageFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html)
11368#[repr(transparent)]
11369#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11370#[doc(alias = "VkIndirectCommandsLayoutUsageFlagBitsNV")]
11371pub struct IndirectCommandsLayoutUsageFlagBitsNV(u32);
11372impl IndirectCommandsLayoutUsageFlagBitsNV {
11373    #[inline]
11374    pub const fn empty() -> Self {
11375        Self(0u32)
11376    }
11377    #[inline]
11378    pub const fn from_raw(value: u32) -> Self {
11379        Self(value)
11380    }
11381    #[inline]
11382    pub const fn as_raw(self) -> u32 {
11383        self.0
11384    }
11385    #[inline]
11386    pub const fn is_empty(self) -> bool {
11387        self.0 == 0u32
11388    }
11389    #[inline]
11390    pub const fn contains(self, other: Self) -> bool {
11391        (self.0 & other.0) == other.0
11392    }
11393    ///Bit 0.
11394    pub const EXPLICIT_PREPROCESS: Self = Self(1u32);
11395    ///Bit 1.
11396    pub const INDEXED_SEQUENCES: Self = Self(2u32);
11397    ///Bit 2.
11398    pub const UNORDERED_SEQUENCES: Self = Self(4u32);
11399}
11400impl core::ops::BitOr for IndirectCommandsLayoutUsageFlagBitsNV {
11401    type Output = Self;
11402    #[inline]
11403    fn bitor(self, rhs: Self) -> Self {
11404        Self(self.0 | rhs.0)
11405    }
11406}
11407impl core::ops::BitOrAssign for IndirectCommandsLayoutUsageFlagBitsNV {
11408    #[inline]
11409    fn bitor_assign(&mut self, rhs: Self) {
11410        self.0 |= rhs.0;
11411    }
11412}
11413impl core::ops::BitAnd for IndirectCommandsLayoutUsageFlagBitsNV {
11414    type Output = Self;
11415    #[inline]
11416    fn bitand(self, rhs: Self) -> Self {
11417        Self(self.0 & rhs.0)
11418    }
11419}
11420impl core::ops::BitAndAssign for IndirectCommandsLayoutUsageFlagBitsNV {
11421    #[inline]
11422    fn bitand_assign(&mut self, rhs: Self) {
11423        self.0 &= rhs.0;
11424    }
11425}
11426impl core::ops::BitXor for IndirectCommandsLayoutUsageFlagBitsNV {
11427    type Output = Self;
11428    #[inline]
11429    fn bitxor(self, rhs: Self) -> Self {
11430        Self(self.0 ^ rhs.0)
11431    }
11432}
11433impl core::ops::BitXorAssign for IndirectCommandsLayoutUsageFlagBitsNV {
11434    #[inline]
11435    fn bitxor_assign(&mut self, rhs: Self) {
11436        self.0 ^= rhs.0;
11437    }
11438}
11439impl core::ops::Not for IndirectCommandsLayoutUsageFlagBitsNV {
11440    type Output = Self;
11441    #[inline]
11442    fn not(self) -> Self {
11443        Self(!self.0)
11444    }
11445}
11446impl core::fmt::Debug for IndirectCommandsLayoutUsageFlagBitsNV {
11447    #[allow(unused_mut, unused_variables)]
11448    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11449        let mut first = true;
11450        let mut remaining = self.0;
11451        if remaining & Self::EXPLICIT_PREPROCESS.0 != 0 {
11452            if !first {
11453                f.write_str(" | ")?;
11454            }
11455            f.write_str("EXPLICIT_PREPROCESS")?;
11456            remaining &= !Self::EXPLICIT_PREPROCESS.0;
11457            first = false;
11458        }
11459        if remaining & Self::INDEXED_SEQUENCES.0 != 0 {
11460            if !first {
11461                f.write_str(" | ")?;
11462            }
11463            f.write_str("INDEXED_SEQUENCES")?;
11464            remaining &= !Self::INDEXED_SEQUENCES.0;
11465            first = false;
11466        }
11467        if remaining & Self::UNORDERED_SEQUENCES.0 != 0 {
11468            if !first {
11469                f.write_str(" | ")?;
11470            }
11471            f.write_str("UNORDERED_SEQUENCES")?;
11472            remaining &= !Self::UNORDERED_SEQUENCES.0;
11473            first = false;
11474        }
11475        if remaining != 0u32 {
11476            if !first {
11477                f.write_str(" | ")?;
11478            }
11479            write!(f, "{:#x}", remaining)?;
11480        } else if first {
11481            f.write_str("(empty)")?;
11482        }
11483        Ok(())
11484    }
11485}
11486///[`VkIndirectStateFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectStateFlagBitsNV.html)
11487#[repr(transparent)]
11488#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11489#[doc(alias = "VkIndirectStateFlagBitsNV")]
11490pub struct IndirectStateFlagBitsNV(u32);
11491impl IndirectStateFlagBitsNV {
11492    #[inline]
11493    pub const fn empty() -> Self {
11494        Self(0u32)
11495    }
11496    #[inline]
11497    pub const fn from_raw(value: u32) -> Self {
11498        Self(value)
11499    }
11500    #[inline]
11501    pub const fn as_raw(self) -> u32 {
11502        self.0
11503    }
11504    #[inline]
11505    pub const fn is_empty(self) -> bool {
11506        self.0 == 0u32
11507    }
11508    #[inline]
11509    pub const fn contains(self, other: Self) -> bool {
11510        (self.0 & other.0) == other.0
11511    }
11512    ///Bit 0.
11513    pub const FLAG_FRONTFACE: Self = Self(1u32);
11514}
11515impl core::ops::BitOr for IndirectStateFlagBitsNV {
11516    type Output = Self;
11517    #[inline]
11518    fn bitor(self, rhs: Self) -> Self {
11519        Self(self.0 | rhs.0)
11520    }
11521}
11522impl core::ops::BitOrAssign for IndirectStateFlagBitsNV {
11523    #[inline]
11524    fn bitor_assign(&mut self, rhs: Self) {
11525        self.0 |= rhs.0;
11526    }
11527}
11528impl core::ops::BitAnd for IndirectStateFlagBitsNV {
11529    type Output = Self;
11530    #[inline]
11531    fn bitand(self, rhs: Self) -> Self {
11532        Self(self.0 & rhs.0)
11533    }
11534}
11535impl core::ops::BitAndAssign for IndirectStateFlagBitsNV {
11536    #[inline]
11537    fn bitand_assign(&mut self, rhs: Self) {
11538        self.0 &= rhs.0;
11539    }
11540}
11541impl core::ops::BitXor for IndirectStateFlagBitsNV {
11542    type Output = Self;
11543    #[inline]
11544    fn bitxor(self, rhs: Self) -> Self {
11545        Self(self.0 ^ rhs.0)
11546    }
11547}
11548impl core::ops::BitXorAssign for IndirectStateFlagBitsNV {
11549    #[inline]
11550    fn bitxor_assign(&mut self, rhs: Self) {
11551        self.0 ^= rhs.0;
11552    }
11553}
11554impl core::ops::Not for IndirectStateFlagBitsNV {
11555    type Output = Self;
11556    #[inline]
11557    fn not(self) -> Self {
11558        Self(!self.0)
11559    }
11560}
11561impl core::fmt::Debug for IndirectStateFlagBitsNV {
11562    #[allow(unused_mut, unused_variables)]
11563    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11564        let mut first = true;
11565        let mut remaining = self.0;
11566        if remaining & Self::FLAG_FRONTFACE.0 != 0 {
11567            if !first {
11568                f.write_str(" | ")?;
11569            }
11570            f.write_str("FLAG_FRONTFACE")?;
11571            remaining &= !Self::FLAG_FRONTFACE.0;
11572            first = false;
11573        }
11574        if remaining != 0u32 {
11575            if !first {
11576                f.write_str(" | ")?;
11577            }
11578            write!(f, "{:#x}", remaining)?;
11579        } else if first {
11580            f.write_str("(empty)")?;
11581        }
11582        Ok(())
11583    }
11584}
11585///[`VkInstanceCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateFlagBits.html)
11586#[repr(transparent)]
11587#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11588#[doc(alias = "VkInstanceCreateFlagBits")]
11589pub struct InstanceCreateFlagBits(u32);
11590impl InstanceCreateFlagBits {
11591    #[inline]
11592    pub const fn empty() -> Self {
11593        Self(0u32)
11594    }
11595    #[inline]
11596    pub const fn from_raw(value: u32) -> Self {
11597        Self(value)
11598    }
11599    #[inline]
11600    pub const fn as_raw(self) -> u32 {
11601        self.0
11602    }
11603    #[inline]
11604    pub const fn is_empty(self) -> bool {
11605        self.0 == 0u32
11606    }
11607    #[inline]
11608    pub const fn contains(self, other: Self) -> bool {
11609        (self.0 & other.0) == other.0
11610    }
11611    ///Bit 0.
11612    pub const ENUMERATE_PORTABILITY: Self = Self(1u32);
11613}
11614impl core::ops::BitOr for InstanceCreateFlagBits {
11615    type Output = Self;
11616    #[inline]
11617    fn bitor(self, rhs: Self) -> Self {
11618        Self(self.0 | rhs.0)
11619    }
11620}
11621impl core::ops::BitOrAssign for InstanceCreateFlagBits {
11622    #[inline]
11623    fn bitor_assign(&mut self, rhs: Self) {
11624        self.0 |= rhs.0;
11625    }
11626}
11627impl core::ops::BitAnd for InstanceCreateFlagBits {
11628    type Output = Self;
11629    #[inline]
11630    fn bitand(self, rhs: Self) -> Self {
11631        Self(self.0 & rhs.0)
11632    }
11633}
11634impl core::ops::BitAndAssign for InstanceCreateFlagBits {
11635    #[inline]
11636    fn bitand_assign(&mut self, rhs: Self) {
11637        self.0 &= rhs.0;
11638    }
11639}
11640impl core::ops::BitXor for InstanceCreateFlagBits {
11641    type Output = Self;
11642    #[inline]
11643    fn bitxor(self, rhs: Self) -> Self {
11644        Self(self.0 ^ rhs.0)
11645    }
11646}
11647impl core::ops::BitXorAssign for InstanceCreateFlagBits {
11648    #[inline]
11649    fn bitxor_assign(&mut self, rhs: Self) {
11650        self.0 ^= rhs.0;
11651    }
11652}
11653impl core::ops::Not for InstanceCreateFlagBits {
11654    type Output = Self;
11655    #[inline]
11656    fn not(self) -> Self {
11657        Self(!self.0)
11658    }
11659}
11660impl core::fmt::Debug for InstanceCreateFlagBits {
11661    #[allow(unused_mut, unused_variables)]
11662    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11663        let mut first = true;
11664        let mut remaining = self.0;
11665        if remaining & Self::ENUMERATE_PORTABILITY.0 != 0 {
11666            if !first {
11667                f.write_str(" | ")?;
11668            }
11669            f.write_str("ENUMERATE_PORTABILITY")?;
11670            remaining &= !Self::ENUMERATE_PORTABILITY.0;
11671            first = false;
11672        }
11673        if remaining != 0u32 {
11674            if !first {
11675                f.write_str(" | ")?;
11676            }
11677            write!(f, "{:#x}", remaining)?;
11678        } else if first {
11679            f.write_str("(empty)")?;
11680        }
11681        Ok(())
11682    }
11683}
11684///[`VkMemoryAllocateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateFlagBits.html)
11685#[repr(transparent)]
11686#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11687#[doc(alias = "VkMemoryAllocateFlagBits")]
11688pub struct MemoryAllocateFlagBits(u32);
11689impl MemoryAllocateFlagBits {
11690    #[inline]
11691    pub const fn empty() -> Self {
11692        Self(0u32)
11693    }
11694    #[inline]
11695    pub const fn from_raw(value: u32) -> Self {
11696        Self(value)
11697    }
11698    #[inline]
11699    pub const fn as_raw(self) -> u32 {
11700        self.0
11701    }
11702    #[inline]
11703    pub const fn is_empty(self) -> bool {
11704        self.0 == 0u32
11705    }
11706    #[inline]
11707    pub const fn contains(self, other: Self) -> bool {
11708        (self.0 & other.0) == other.0
11709    }
11710    ///Bit 0.
11711    pub const DEVICE_MASK: Self = Self(1u32);
11712    ///Bit 1.
11713    pub const DEVICE_ADDRESS: Self = Self(2u32);
11714    ///Bit 2.
11715    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(4u32);
11716    ///Bit 3.
11717    pub const ZERO_INITIALIZE: Self = Self(8u32);
11718}
11719impl core::ops::BitOr for MemoryAllocateFlagBits {
11720    type Output = Self;
11721    #[inline]
11722    fn bitor(self, rhs: Self) -> Self {
11723        Self(self.0 | rhs.0)
11724    }
11725}
11726impl core::ops::BitOrAssign for MemoryAllocateFlagBits {
11727    #[inline]
11728    fn bitor_assign(&mut self, rhs: Self) {
11729        self.0 |= rhs.0;
11730    }
11731}
11732impl core::ops::BitAnd for MemoryAllocateFlagBits {
11733    type Output = Self;
11734    #[inline]
11735    fn bitand(self, rhs: Self) -> Self {
11736        Self(self.0 & rhs.0)
11737    }
11738}
11739impl core::ops::BitAndAssign for MemoryAllocateFlagBits {
11740    #[inline]
11741    fn bitand_assign(&mut self, rhs: Self) {
11742        self.0 &= rhs.0;
11743    }
11744}
11745impl core::ops::BitXor for MemoryAllocateFlagBits {
11746    type Output = Self;
11747    #[inline]
11748    fn bitxor(self, rhs: Self) -> Self {
11749        Self(self.0 ^ rhs.0)
11750    }
11751}
11752impl core::ops::BitXorAssign for MemoryAllocateFlagBits {
11753    #[inline]
11754    fn bitxor_assign(&mut self, rhs: Self) {
11755        self.0 ^= rhs.0;
11756    }
11757}
11758impl core::ops::Not for MemoryAllocateFlagBits {
11759    type Output = Self;
11760    #[inline]
11761    fn not(self) -> Self {
11762        Self(!self.0)
11763    }
11764}
11765impl core::fmt::Debug for MemoryAllocateFlagBits {
11766    #[allow(unused_mut, unused_variables)]
11767    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11768        let mut first = true;
11769        let mut remaining = self.0;
11770        if remaining & Self::DEVICE_MASK.0 != 0 {
11771            if !first {
11772                f.write_str(" | ")?;
11773            }
11774            f.write_str("DEVICE_MASK")?;
11775            remaining &= !Self::DEVICE_MASK.0;
11776            first = false;
11777        }
11778        if remaining & Self::DEVICE_ADDRESS.0 != 0 {
11779            if !first {
11780                f.write_str(" | ")?;
11781            }
11782            f.write_str("DEVICE_ADDRESS")?;
11783            remaining &= !Self::DEVICE_ADDRESS.0;
11784            first = false;
11785        }
11786        if remaining & Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0 != 0 {
11787            if !first {
11788                f.write_str(" | ")?;
11789            }
11790            f.write_str("DEVICE_ADDRESS_CAPTURE_REPLAY")?;
11791            remaining &= !Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0;
11792            first = false;
11793        }
11794        if remaining & Self::ZERO_INITIALIZE.0 != 0 {
11795            if !first {
11796                f.write_str(" | ")?;
11797            }
11798            f.write_str("ZERO_INITIALIZE")?;
11799            remaining &= !Self::ZERO_INITIALIZE.0;
11800            first = false;
11801        }
11802        if remaining != 0u32 {
11803            if !first {
11804                f.write_str(" | ")?;
11805            }
11806            write!(f, "{:#x}", remaining)?;
11807        } else if first {
11808            f.write_str("(empty)")?;
11809        }
11810        Ok(())
11811    }
11812}
11813///[`VkMemoryDecompressionMethodFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDecompressionMethodFlagBitsEXT.html)
11814#[repr(transparent)]
11815#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11816#[doc(alias = "VkMemoryDecompressionMethodFlagBitsEXT")]
11817pub struct MemoryDecompressionMethodFlagBitsEXT(u64);
11818impl MemoryDecompressionMethodFlagBitsEXT {
11819    #[inline]
11820    pub const fn empty() -> Self {
11821        Self(0u64)
11822    }
11823    #[inline]
11824    pub const fn from_raw(value: u64) -> Self {
11825        Self(value)
11826    }
11827    #[inline]
11828    pub const fn as_raw(self) -> u64 {
11829        self.0
11830    }
11831    #[inline]
11832    pub const fn is_empty(self) -> bool {
11833        self.0 == 0u64
11834    }
11835    #[inline]
11836    pub const fn contains(self, other: Self) -> bool {
11837        (self.0 & other.0) == other.0
11838    }
11839    ///Bit 0.
11840    pub const GDEFLATE_1_0: Self = Self(1u64);
11841}
11842impl core::ops::BitOr for MemoryDecompressionMethodFlagBitsEXT {
11843    type Output = Self;
11844    #[inline]
11845    fn bitor(self, rhs: Self) -> Self {
11846        Self(self.0 | rhs.0)
11847    }
11848}
11849impl core::ops::BitOrAssign for MemoryDecompressionMethodFlagBitsEXT {
11850    #[inline]
11851    fn bitor_assign(&mut self, rhs: Self) {
11852        self.0 |= rhs.0;
11853    }
11854}
11855impl core::ops::BitAnd for MemoryDecompressionMethodFlagBitsEXT {
11856    type Output = Self;
11857    #[inline]
11858    fn bitand(self, rhs: Self) -> Self {
11859        Self(self.0 & rhs.0)
11860    }
11861}
11862impl core::ops::BitAndAssign for MemoryDecompressionMethodFlagBitsEXT {
11863    #[inline]
11864    fn bitand_assign(&mut self, rhs: Self) {
11865        self.0 &= rhs.0;
11866    }
11867}
11868impl core::ops::BitXor for MemoryDecompressionMethodFlagBitsEXT {
11869    type Output = Self;
11870    #[inline]
11871    fn bitxor(self, rhs: Self) -> Self {
11872        Self(self.0 ^ rhs.0)
11873    }
11874}
11875impl core::ops::BitXorAssign for MemoryDecompressionMethodFlagBitsEXT {
11876    #[inline]
11877    fn bitxor_assign(&mut self, rhs: Self) {
11878        self.0 ^= rhs.0;
11879    }
11880}
11881impl core::ops::Not for MemoryDecompressionMethodFlagBitsEXT {
11882    type Output = Self;
11883    #[inline]
11884    fn not(self) -> Self {
11885        Self(!self.0)
11886    }
11887}
11888impl core::fmt::Debug for MemoryDecompressionMethodFlagBitsEXT {
11889    #[allow(unused_mut, unused_variables)]
11890    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11891        let mut first = true;
11892        let mut remaining = self.0;
11893        if remaining & Self::GDEFLATE_1_0.0 != 0 {
11894            if !first {
11895                f.write_str(" | ")?;
11896            }
11897            f.write_str("GDEFLATE_1_0")?;
11898            remaining &= !Self::GDEFLATE_1_0.0;
11899            first = false;
11900        }
11901        if remaining != 0u64 {
11902            if !first {
11903                f.write_str(" | ")?;
11904            }
11905            write!(f, "{:#x}", remaining)?;
11906        } else if first {
11907            f.write_str("(empty)")?;
11908        }
11909        Ok(())
11910    }
11911}
11912///[`VkMemoryHeapFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeapFlagBits.html)
11913#[repr(transparent)]
11914#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
11915#[doc(alias = "VkMemoryHeapFlagBits")]
11916pub struct MemoryHeapFlagBits(u32);
11917impl MemoryHeapFlagBits {
11918    #[inline]
11919    pub const fn empty() -> Self {
11920        Self(0u32)
11921    }
11922    #[inline]
11923    pub const fn from_raw(value: u32) -> Self {
11924        Self(value)
11925    }
11926    #[inline]
11927    pub const fn as_raw(self) -> u32 {
11928        self.0
11929    }
11930    #[inline]
11931    pub const fn is_empty(self) -> bool {
11932        self.0 == 0u32
11933    }
11934    #[inline]
11935    pub const fn contains(self, other: Self) -> bool {
11936        (self.0 & other.0) == other.0
11937    }
11938    ///Bit 0.
11939    pub const DEVICE_LOCAL: Self = Self(1u32);
11940    ///Bit 1.
11941    pub const MULTI_INSTANCE: Self = Self(2u32);
11942    ///Bit 2.
11943    pub const SEU_SAFE: Self = Self(4u32);
11944    ///Bit 3.
11945    pub const TILE_MEMORY_BIT: Self = Self(8u32);
11946}
11947impl core::ops::BitOr for MemoryHeapFlagBits {
11948    type Output = Self;
11949    #[inline]
11950    fn bitor(self, rhs: Self) -> Self {
11951        Self(self.0 | rhs.0)
11952    }
11953}
11954impl core::ops::BitOrAssign for MemoryHeapFlagBits {
11955    #[inline]
11956    fn bitor_assign(&mut self, rhs: Self) {
11957        self.0 |= rhs.0;
11958    }
11959}
11960impl core::ops::BitAnd for MemoryHeapFlagBits {
11961    type Output = Self;
11962    #[inline]
11963    fn bitand(self, rhs: Self) -> Self {
11964        Self(self.0 & rhs.0)
11965    }
11966}
11967impl core::ops::BitAndAssign for MemoryHeapFlagBits {
11968    #[inline]
11969    fn bitand_assign(&mut self, rhs: Self) {
11970        self.0 &= rhs.0;
11971    }
11972}
11973impl core::ops::BitXor for MemoryHeapFlagBits {
11974    type Output = Self;
11975    #[inline]
11976    fn bitxor(self, rhs: Self) -> Self {
11977        Self(self.0 ^ rhs.0)
11978    }
11979}
11980impl core::ops::BitXorAssign for MemoryHeapFlagBits {
11981    #[inline]
11982    fn bitxor_assign(&mut self, rhs: Self) {
11983        self.0 ^= rhs.0;
11984    }
11985}
11986impl core::ops::Not for MemoryHeapFlagBits {
11987    type Output = Self;
11988    #[inline]
11989    fn not(self) -> Self {
11990        Self(!self.0)
11991    }
11992}
11993impl core::fmt::Debug for MemoryHeapFlagBits {
11994    #[allow(unused_mut, unused_variables)]
11995    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11996        let mut first = true;
11997        let mut remaining = self.0;
11998        if remaining & Self::DEVICE_LOCAL.0 != 0 {
11999            if !first {
12000                f.write_str(" | ")?;
12001            }
12002            f.write_str("DEVICE_LOCAL")?;
12003            remaining &= !Self::DEVICE_LOCAL.0;
12004            first = false;
12005        }
12006        if remaining & Self::MULTI_INSTANCE.0 != 0 {
12007            if !first {
12008                f.write_str(" | ")?;
12009            }
12010            f.write_str("MULTI_INSTANCE")?;
12011            remaining &= !Self::MULTI_INSTANCE.0;
12012            first = false;
12013        }
12014        if remaining & Self::SEU_SAFE.0 != 0 {
12015            if !first {
12016                f.write_str(" | ")?;
12017            }
12018            f.write_str("SEU_SAFE")?;
12019            remaining &= !Self::SEU_SAFE.0;
12020            first = false;
12021        }
12022        if remaining & Self::TILE_MEMORY_BIT.0 != 0 {
12023            if !first {
12024                f.write_str(" | ")?;
12025            }
12026            f.write_str("TILE_MEMORY_BIT")?;
12027            remaining &= !Self::TILE_MEMORY_BIT.0;
12028            first = false;
12029        }
12030        if remaining != 0u32 {
12031            if !first {
12032                f.write_str(" | ")?;
12033            }
12034            write!(f, "{:#x}", remaining)?;
12035        } else if first {
12036            f.write_str("(empty)")?;
12037        }
12038        Ok(())
12039    }
12040}
12041///[`VkMemoryMapFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapFlagBits.html)
12042#[repr(transparent)]
12043#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
12044#[doc(alias = "VkMemoryMapFlagBits")]
12045pub struct MemoryMapFlagBits(u32);
12046impl MemoryMapFlagBits {
12047    #[inline]
12048    pub const fn empty() -> Self {
12049        Self(0u32)
12050    }
12051    #[inline]
12052    pub const fn from_raw(value: u32) -> Self {
12053        Self(value)
12054    }
12055    #[inline]
12056    pub const fn as_raw(self) -> u32 {
12057        self.0
12058    }
12059    #[inline]
12060    pub const fn is_empty(self) -> bool {
12061        self.0 == 0u32
12062    }
12063    #[inline]
12064    pub const fn contains(self, other: Self) -> bool {
12065        (self.0 & other.0) == other.0
12066    }
12067    ///Bit 0.
12068    pub const PLACED: Self = Self(1u32);
12069}
12070impl core::ops::BitOr for MemoryMapFlagBits {
12071    type Output = Self;
12072    #[inline]
12073    fn bitor(self, rhs: Self) -> Self {
12074        Self(self.0 | rhs.0)
12075    }
12076}
12077impl core::ops::BitOrAssign for MemoryMapFlagBits {
12078    #[inline]
12079    fn bitor_assign(&mut self, rhs: Self) {
12080        self.0 |= rhs.0;
12081    }
12082}
12083impl core::ops::BitAnd for MemoryMapFlagBits {
12084    type Output = Self;
12085    #[inline]
12086    fn bitand(self, rhs: Self) -> Self {
12087        Self(self.0 & rhs.0)
12088    }
12089}
12090impl core::ops::BitAndAssign for MemoryMapFlagBits {
12091    #[inline]
12092    fn bitand_assign(&mut self, rhs: Self) {
12093        self.0 &= rhs.0;
12094    }
12095}
12096impl core::ops::BitXor for MemoryMapFlagBits {
12097    type Output = Self;
12098    #[inline]
12099    fn bitxor(self, rhs: Self) -> Self {
12100        Self(self.0 ^ rhs.0)
12101    }
12102}
12103impl core::ops::BitXorAssign for MemoryMapFlagBits {
12104    #[inline]
12105    fn bitxor_assign(&mut self, rhs: Self) {
12106        self.0 ^= rhs.0;
12107    }
12108}
12109impl core::ops::Not for MemoryMapFlagBits {
12110    type Output = Self;
12111    #[inline]
12112    fn not(self) -> Self {
12113        Self(!self.0)
12114    }
12115}
12116impl core::fmt::Debug for MemoryMapFlagBits {
12117    #[allow(unused_mut, unused_variables)]
12118    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12119        let mut first = true;
12120        let mut remaining = self.0;
12121        if remaining & Self::PLACED.0 != 0 {
12122            if !first {
12123                f.write_str(" | ")?;
12124            }
12125            f.write_str("PLACED")?;
12126            remaining &= !Self::PLACED.0;
12127            first = false;
12128        }
12129        if remaining != 0u32 {
12130            if !first {
12131                f.write_str(" | ")?;
12132            }
12133            write!(f, "{:#x}", remaining)?;
12134        } else if first {
12135            f.write_str("(empty)")?;
12136        }
12137        Ok(())
12138    }
12139}
12140///[`VkMemoryPropertyFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPropertyFlagBits.html)
12141#[repr(transparent)]
12142#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
12143#[doc(alias = "VkMemoryPropertyFlagBits")]
12144pub struct MemoryPropertyFlagBits(u32);
12145impl MemoryPropertyFlagBits {
12146    #[inline]
12147    pub const fn empty() -> Self {
12148        Self(0u32)
12149    }
12150    #[inline]
12151    pub const fn from_raw(value: u32) -> Self {
12152        Self(value)
12153    }
12154    #[inline]
12155    pub const fn as_raw(self) -> u32 {
12156        self.0
12157    }
12158    #[inline]
12159    pub const fn is_empty(self) -> bool {
12160        self.0 == 0u32
12161    }
12162    #[inline]
12163    pub const fn contains(self, other: Self) -> bool {
12164        (self.0 & other.0) == other.0
12165    }
12166    ///Bit 0.
12167    pub const DEVICE_LOCAL: Self = Self(1u32);
12168    ///Bit 1.
12169    pub const HOST_VISIBLE: Self = Self(2u32);
12170    ///Bit 2.
12171    pub const HOST_COHERENT: Self = Self(4u32);
12172    ///Bit 3.
12173    pub const HOST_CACHED: Self = Self(8u32);
12174    ///Bit 4.
12175    pub const LAZILY_ALLOCATED: Self = Self(16u32);
12176    ///Bit 5.
12177    pub const PROTECTED: Self = Self(32u32);
12178    ///Bit 6.
12179    pub const DEVICE_COHERENT: Self = Self(64u32);
12180    ///Bit 7.
12181    pub const DEVICE_UNCACHED: Self = Self(128u32);
12182    ///Bit 8.
12183    pub const RDMA_CAPABLE: Self = Self(256u32);
12184}
12185impl core::ops::BitOr for MemoryPropertyFlagBits {
12186    type Output = Self;
12187    #[inline]
12188    fn bitor(self, rhs: Self) -> Self {
12189        Self(self.0 | rhs.0)
12190    }
12191}
12192impl core::ops::BitOrAssign for MemoryPropertyFlagBits {
12193    #[inline]
12194    fn bitor_assign(&mut self, rhs: Self) {
12195        self.0 |= rhs.0;
12196    }
12197}
12198impl core::ops::BitAnd for MemoryPropertyFlagBits {
12199    type Output = Self;
12200    #[inline]
12201    fn bitand(self, rhs: Self) -> Self {
12202        Self(self.0 & rhs.0)
12203    }
12204}
12205impl core::ops::BitAndAssign for MemoryPropertyFlagBits {
12206    #[inline]
12207    fn bitand_assign(&mut self, rhs: Self) {
12208        self.0 &= rhs.0;
12209    }
12210}
12211impl core::ops::BitXor for MemoryPropertyFlagBits {
12212    type Output = Self;
12213    #[inline]
12214    fn bitxor(self, rhs: Self) -> Self {
12215        Self(self.0 ^ rhs.0)
12216    }
12217}
12218impl core::ops::BitXorAssign for MemoryPropertyFlagBits {
12219    #[inline]
12220    fn bitxor_assign(&mut self, rhs: Self) {
12221        self.0 ^= rhs.0;
12222    }
12223}
12224impl core::ops::Not for MemoryPropertyFlagBits {
12225    type Output = Self;
12226    #[inline]
12227    fn not(self) -> Self {
12228        Self(!self.0)
12229    }
12230}
12231impl core::fmt::Debug for MemoryPropertyFlagBits {
12232    #[allow(unused_mut, unused_variables)]
12233    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12234        let mut first = true;
12235        let mut remaining = self.0;
12236        if remaining & Self::DEVICE_LOCAL.0 != 0 {
12237            if !first {
12238                f.write_str(" | ")?;
12239            }
12240            f.write_str("DEVICE_LOCAL")?;
12241            remaining &= !Self::DEVICE_LOCAL.0;
12242            first = false;
12243        }
12244        if remaining & Self::HOST_VISIBLE.0 != 0 {
12245            if !first {
12246                f.write_str(" | ")?;
12247            }
12248            f.write_str("HOST_VISIBLE")?;
12249            remaining &= !Self::HOST_VISIBLE.0;
12250            first = false;
12251        }
12252        if remaining & Self::HOST_COHERENT.0 != 0 {
12253            if !first {
12254                f.write_str(" | ")?;
12255            }
12256            f.write_str("HOST_COHERENT")?;
12257            remaining &= !Self::HOST_COHERENT.0;
12258            first = false;
12259        }
12260        if remaining & Self::HOST_CACHED.0 != 0 {
12261            if !first {
12262                f.write_str(" | ")?;
12263            }
12264            f.write_str("HOST_CACHED")?;
12265            remaining &= !Self::HOST_CACHED.0;
12266            first = false;
12267        }
12268        if remaining & Self::LAZILY_ALLOCATED.0 != 0 {
12269            if !first {
12270                f.write_str(" | ")?;
12271            }
12272            f.write_str("LAZILY_ALLOCATED")?;
12273            remaining &= !Self::LAZILY_ALLOCATED.0;
12274            first = false;
12275        }
12276        if remaining & Self::PROTECTED.0 != 0 {
12277            if !first {
12278                f.write_str(" | ")?;
12279            }
12280            f.write_str("PROTECTED")?;
12281            remaining &= !Self::PROTECTED.0;
12282            first = false;
12283        }
12284        if remaining & Self::DEVICE_COHERENT.0 != 0 {
12285            if !first {
12286                f.write_str(" | ")?;
12287            }
12288            f.write_str("DEVICE_COHERENT")?;
12289            remaining &= !Self::DEVICE_COHERENT.0;
12290            first = false;
12291        }
12292        if remaining & Self::DEVICE_UNCACHED.0 != 0 {
12293            if !first {
12294                f.write_str(" | ")?;
12295            }
12296            f.write_str("DEVICE_UNCACHED")?;
12297            remaining &= !Self::DEVICE_UNCACHED.0;
12298            first = false;
12299        }
12300        if remaining & Self::RDMA_CAPABLE.0 != 0 {
12301            if !first {
12302                f.write_str(" | ")?;
12303            }
12304            f.write_str("RDMA_CAPABLE")?;
12305            remaining &= !Self::RDMA_CAPABLE.0;
12306            first = false;
12307        }
12308        if remaining != 0u32 {
12309            if !first {
12310                f.write_str(" | ")?;
12311            }
12312            write!(f, "{:#x}", remaining)?;
12313        } else if first {
12314            f.write_str("(empty)")?;
12315        }
12316        Ok(())
12317    }
12318}
12319///[`VkMemoryUnmapFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryUnmapFlagBits.html)
12320#[repr(transparent)]
12321#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
12322#[doc(alias = "VkMemoryUnmapFlagBits")]
12323pub struct MemoryUnmapFlagBits(u32);
12324impl MemoryUnmapFlagBits {
12325    #[inline]
12326    pub const fn empty() -> Self {
12327        Self(0u32)
12328    }
12329    #[inline]
12330    pub const fn from_raw(value: u32) -> Self {
12331        Self(value)
12332    }
12333    #[inline]
12334    pub const fn as_raw(self) -> u32 {
12335        self.0
12336    }
12337    #[inline]
12338    pub const fn is_empty(self) -> bool {
12339        self.0 == 0u32
12340    }
12341    #[inline]
12342    pub const fn contains(self, other: Self) -> bool {
12343        (self.0 & other.0) == other.0
12344    }
12345    ///Bit 0.
12346    pub const RESERVE: Self = Self(1u32);
12347}
12348impl core::ops::BitOr for MemoryUnmapFlagBits {
12349    type Output = Self;
12350    #[inline]
12351    fn bitor(self, rhs: Self) -> Self {
12352        Self(self.0 | rhs.0)
12353    }
12354}
12355impl core::ops::BitOrAssign for MemoryUnmapFlagBits {
12356    #[inline]
12357    fn bitor_assign(&mut self, rhs: Self) {
12358        self.0 |= rhs.0;
12359    }
12360}
12361impl core::ops::BitAnd for MemoryUnmapFlagBits {
12362    type Output = Self;
12363    #[inline]
12364    fn bitand(self, rhs: Self) -> Self {
12365        Self(self.0 & rhs.0)
12366    }
12367}
12368impl core::ops::BitAndAssign for MemoryUnmapFlagBits {
12369    #[inline]
12370    fn bitand_assign(&mut self, rhs: Self) {
12371        self.0 &= rhs.0;
12372    }
12373}
12374impl core::ops::BitXor for MemoryUnmapFlagBits {
12375    type Output = Self;
12376    #[inline]
12377    fn bitxor(self, rhs: Self) -> Self {
12378        Self(self.0 ^ rhs.0)
12379    }
12380}
12381impl core::ops::BitXorAssign for MemoryUnmapFlagBits {
12382    #[inline]
12383    fn bitxor_assign(&mut self, rhs: Self) {
12384        self.0 ^= rhs.0;
12385    }
12386}
12387impl core::ops::Not for MemoryUnmapFlagBits {
12388    type Output = Self;
12389    #[inline]
12390    fn not(self) -> Self {
12391        Self(!self.0)
12392    }
12393}
12394impl core::fmt::Debug for MemoryUnmapFlagBits {
12395    #[allow(unused_mut, unused_variables)]
12396    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12397        let mut first = true;
12398        let mut remaining = self.0;
12399        if remaining & Self::RESERVE.0 != 0 {
12400            if !first {
12401                f.write_str(" | ")?;
12402            }
12403            f.write_str("RESERVE")?;
12404            remaining &= !Self::RESERVE.0;
12405            first = false;
12406        }
12407        if remaining != 0u32 {
12408            if !first {
12409                f.write_str(" | ")?;
12410            }
12411            write!(f, "{:#x}", remaining)?;
12412        } else if first {
12413            f.write_str("(empty)")?;
12414        }
12415        Ok(())
12416    }
12417}
12418///[`VkMicromapCreateFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapCreateFlagBitsEXT.html)
12419#[repr(transparent)]
12420#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
12421#[doc(alias = "VkMicromapCreateFlagBitsEXT")]
12422pub struct MicromapCreateFlagBitsEXT(u32);
12423impl MicromapCreateFlagBitsEXT {
12424    #[inline]
12425    pub const fn empty() -> Self {
12426        Self(0u32)
12427    }
12428    #[inline]
12429    pub const fn from_raw(value: u32) -> Self {
12430        Self(value)
12431    }
12432    #[inline]
12433    pub const fn as_raw(self) -> u32 {
12434        self.0
12435    }
12436    #[inline]
12437    pub const fn is_empty(self) -> bool {
12438        self.0 == 0u32
12439    }
12440    #[inline]
12441    pub const fn contains(self, other: Self) -> bool {
12442        (self.0 & other.0) == other.0
12443    }
12444    ///Bit 0.
12445    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(1u32);
12446}
12447impl core::ops::BitOr for MicromapCreateFlagBitsEXT {
12448    type Output = Self;
12449    #[inline]
12450    fn bitor(self, rhs: Self) -> Self {
12451        Self(self.0 | rhs.0)
12452    }
12453}
12454impl core::ops::BitOrAssign for MicromapCreateFlagBitsEXT {
12455    #[inline]
12456    fn bitor_assign(&mut self, rhs: Self) {
12457        self.0 |= rhs.0;
12458    }
12459}
12460impl core::ops::BitAnd for MicromapCreateFlagBitsEXT {
12461    type Output = Self;
12462    #[inline]
12463    fn bitand(self, rhs: Self) -> Self {
12464        Self(self.0 & rhs.0)
12465    }
12466}
12467impl core::ops::BitAndAssign for MicromapCreateFlagBitsEXT {
12468    #[inline]
12469    fn bitand_assign(&mut self, rhs: Self) {
12470        self.0 &= rhs.0;
12471    }
12472}
12473impl core::ops::BitXor for MicromapCreateFlagBitsEXT {
12474    type Output = Self;
12475    #[inline]
12476    fn bitxor(self, rhs: Self) -> Self {
12477        Self(self.0 ^ rhs.0)
12478    }
12479}
12480impl core::ops::BitXorAssign for MicromapCreateFlagBitsEXT {
12481    #[inline]
12482    fn bitxor_assign(&mut self, rhs: Self) {
12483        self.0 ^= rhs.0;
12484    }
12485}
12486impl core::ops::Not for MicromapCreateFlagBitsEXT {
12487    type Output = Self;
12488    #[inline]
12489    fn not(self) -> Self {
12490        Self(!self.0)
12491    }
12492}
12493impl core::fmt::Debug for MicromapCreateFlagBitsEXT {
12494    #[allow(unused_mut, unused_variables)]
12495    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12496        let mut first = true;
12497        let mut remaining = self.0;
12498        if remaining & Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0 != 0 {
12499            if !first {
12500                f.write_str(" | ")?;
12501            }
12502            f.write_str("DEVICE_ADDRESS_CAPTURE_REPLAY")?;
12503            remaining &= !Self::DEVICE_ADDRESS_CAPTURE_REPLAY.0;
12504            first = false;
12505        }
12506        if remaining != 0u32 {
12507            if !first {
12508                f.write_str(" | ")?;
12509            }
12510            write!(f, "{:#x}", remaining)?;
12511        } else if first {
12512            f.write_str("(empty)")?;
12513        }
12514        Ok(())
12515    }
12516}
12517///[`VkOpticalFlowExecuteFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowExecuteFlagBitsNV.html)
12518#[repr(transparent)]
12519#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
12520#[doc(alias = "VkOpticalFlowExecuteFlagBitsNV")]
12521pub struct OpticalFlowExecuteFlagBitsNV(u32);
12522impl OpticalFlowExecuteFlagBitsNV {
12523    #[inline]
12524    pub const fn empty() -> Self {
12525        Self(0u32)
12526    }
12527    #[inline]
12528    pub const fn from_raw(value: u32) -> Self {
12529        Self(value)
12530    }
12531    #[inline]
12532    pub const fn as_raw(self) -> u32 {
12533        self.0
12534    }
12535    #[inline]
12536    pub const fn is_empty(self) -> bool {
12537        self.0 == 0u32
12538    }
12539    #[inline]
12540    pub const fn contains(self, other: Self) -> bool {
12541        (self.0 & other.0) == other.0
12542    }
12543    ///Bit 0.
12544    pub const DISABLE_TEMPORAL_HINTS: Self = Self(1u32);
12545}
12546impl core::ops::BitOr for OpticalFlowExecuteFlagBitsNV {
12547    type Output = Self;
12548    #[inline]
12549    fn bitor(self, rhs: Self) -> Self {
12550        Self(self.0 | rhs.0)
12551    }
12552}
12553impl core::ops::BitOrAssign for OpticalFlowExecuteFlagBitsNV {
12554    #[inline]
12555    fn bitor_assign(&mut self, rhs: Self) {
12556        self.0 |= rhs.0;
12557    }
12558}
12559impl core::ops::BitAnd for OpticalFlowExecuteFlagBitsNV {
12560    type Output = Self;
12561    #[inline]
12562    fn bitand(self, rhs: Self) -> Self {
12563        Self(self.0 & rhs.0)
12564    }
12565}
12566impl core::ops::BitAndAssign for OpticalFlowExecuteFlagBitsNV {
12567    #[inline]
12568    fn bitand_assign(&mut self, rhs: Self) {
12569        self.0 &= rhs.0;
12570    }
12571}
12572impl core::ops::BitXor for OpticalFlowExecuteFlagBitsNV {
12573    type Output = Self;
12574    #[inline]
12575    fn bitxor(self, rhs: Self) -> Self {
12576        Self(self.0 ^ rhs.0)
12577    }
12578}
12579impl core::ops::BitXorAssign for OpticalFlowExecuteFlagBitsNV {
12580    #[inline]
12581    fn bitxor_assign(&mut self, rhs: Self) {
12582        self.0 ^= rhs.0;
12583    }
12584}
12585impl core::ops::Not for OpticalFlowExecuteFlagBitsNV {
12586    type Output = Self;
12587    #[inline]
12588    fn not(self) -> Self {
12589        Self(!self.0)
12590    }
12591}
12592impl core::fmt::Debug for OpticalFlowExecuteFlagBitsNV {
12593    #[allow(unused_mut, unused_variables)]
12594    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12595        let mut first = true;
12596        let mut remaining = self.0;
12597        if remaining & Self::DISABLE_TEMPORAL_HINTS.0 != 0 {
12598            if !first {
12599                f.write_str(" | ")?;
12600            }
12601            f.write_str("DISABLE_TEMPORAL_HINTS")?;
12602            remaining &= !Self::DISABLE_TEMPORAL_HINTS.0;
12603            first = false;
12604        }
12605        if remaining != 0u32 {
12606            if !first {
12607                f.write_str(" | ")?;
12608            }
12609            write!(f, "{:#x}", remaining)?;
12610        } else if first {
12611            f.write_str("(empty)")?;
12612        }
12613        Ok(())
12614    }
12615}
12616///[`VkOpticalFlowGridSizeFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowGridSizeFlagBitsNV.html)
12617#[repr(transparent)]
12618#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
12619#[doc(alias = "VkOpticalFlowGridSizeFlagBitsNV")]
12620pub struct OpticalFlowGridSizeFlagBitsNV(u32);
12621impl OpticalFlowGridSizeFlagBitsNV {
12622    #[inline]
12623    pub const fn empty() -> Self {
12624        Self(0u32)
12625    }
12626    #[inline]
12627    pub const fn from_raw(value: u32) -> Self {
12628        Self(value)
12629    }
12630    #[inline]
12631    pub const fn as_raw(self) -> u32 {
12632        self.0
12633    }
12634    #[inline]
12635    pub const fn is_empty(self) -> bool {
12636        self.0 == 0u32
12637    }
12638    #[inline]
12639    pub const fn contains(self, other: Self) -> bool {
12640        (self.0 & other.0) == other.0
12641    }
12642    pub const UNKNOWN: Self = Self(0u32);
12643    ///Bit 0.
12644    pub const _1X1: Self = Self(1u32);
12645    ///Bit 1.
12646    pub const _2X2: Self = Self(2u32);
12647    ///Bit 2.
12648    pub const _4X4: Self = Self(4u32);
12649    ///Bit 3.
12650    pub const _8X8: Self = Self(8u32);
12651}
12652impl core::ops::BitOr for OpticalFlowGridSizeFlagBitsNV {
12653    type Output = Self;
12654    #[inline]
12655    fn bitor(self, rhs: Self) -> Self {
12656        Self(self.0 | rhs.0)
12657    }
12658}
12659impl core::ops::BitOrAssign for OpticalFlowGridSizeFlagBitsNV {
12660    #[inline]
12661    fn bitor_assign(&mut self, rhs: Self) {
12662        self.0 |= rhs.0;
12663    }
12664}
12665impl core::ops::BitAnd for OpticalFlowGridSizeFlagBitsNV {
12666    type Output = Self;
12667    #[inline]
12668    fn bitand(self, rhs: Self) -> Self {
12669        Self(self.0 & rhs.0)
12670    }
12671}
12672impl core::ops::BitAndAssign for OpticalFlowGridSizeFlagBitsNV {
12673    #[inline]
12674    fn bitand_assign(&mut self, rhs: Self) {
12675        self.0 &= rhs.0;
12676    }
12677}
12678impl core::ops::BitXor for OpticalFlowGridSizeFlagBitsNV {
12679    type Output = Self;
12680    #[inline]
12681    fn bitxor(self, rhs: Self) -> Self {
12682        Self(self.0 ^ rhs.0)
12683    }
12684}
12685impl core::ops::BitXorAssign for OpticalFlowGridSizeFlagBitsNV {
12686    #[inline]
12687    fn bitxor_assign(&mut self, rhs: Self) {
12688        self.0 ^= rhs.0;
12689    }
12690}
12691impl core::ops::Not for OpticalFlowGridSizeFlagBitsNV {
12692    type Output = Self;
12693    #[inline]
12694    fn not(self) -> Self {
12695        Self(!self.0)
12696    }
12697}
12698impl core::fmt::Debug for OpticalFlowGridSizeFlagBitsNV {
12699    #[allow(unused_mut, unused_variables)]
12700    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12701        let mut first = true;
12702        let mut remaining = self.0;
12703        if remaining & Self::_1X1.0 != 0 {
12704            if !first {
12705                f.write_str(" | ")?;
12706            }
12707            f.write_str("_1X1")?;
12708            remaining &= !Self::_1X1.0;
12709            first = false;
12710        }
12711        if remaining & Self::_2X2.0 != 0 {
12712            if !first {
12713                f.write_str(" | ")?;
12714            }
12715            f.write_str("_2X2")?;
12716            remaining &= !Self::_2X2.0;
12717            first = false;
12718        }
12719        if remaining & Self::_4X4.0 != 0 {
12720            if !first {
12721                f.write_str(" | ")?;
12722            }
12723            f.write_str("_4X4")?;
12724            remaining &= !Self::_4X4.0;
12725            first = false;
12726        }
12727        if remaining & Self::_8X8.0 != 0 {
12728            if !first {
12729                f.write_str(" | ")?;
12730            }
12731            f.write_str("_8X8")?;
12732            remaining &= !Self::_8X8.0;
12733            first = false;
12734        }
12735        if remaining != 0u32 {
12736            if !first {
12737                f.write_str(" | ")?;
12738            }
12739            write!(f, "{:#x}", remaining)?;
12740        } else if first {
12741            f.write_str("(empty)")?;
12742        }
12743        Ok(())
12744    }
12745}
12746///[`VkOpticalFlowSessionCreateFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateFlagBitsNV.html)
12747#[repr(transparent)]
12748#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
12749#[doc(alias = "VkOpticalFlowSessionCreateFlagBitsNV")]
12750pub struct OpticalFlowSessionCreateFlagBitsNV(u32);
12751impl OpticalFlowSessionCreateFlagBitsNV {
12752    #[inline]
12753    pub const fn empty() -> Self {
12754        Self(0u32)
12755    }
12756    #[inline]
12757    pub const fn from_raw(value: u32) -> Self {
12758        Self(value)
12759    }
12760    #[inline]
12761    pub const fn as_raw(self) -> u32 {
12762        self.0
12763    }
12764    #[inline]
12765    pub const fn is_empty(self) -> bool {
12766        self.0 == 0u32
12767    }
12768    #[inline]
12769    pub const fn contains(self, other: Self) -> bool {
12770        (self.0 & other.0) == other.0
12771    }
12772    ///Bit 0.
12773    pub const ENABLE_HINT: Self = Self(1u32);
12774    ///Bit 1.
12775    pub const ENABLE_COST: Self = Self(2u32);
12776    ///Bit 2.
12777    pub const ENABLE_GLOBAL_FLOW: Self = Self(4u32);
12778    ///Bit 3.
12779    pub const ALLOW_REGIONS: Self = Self(8u32);
12780    ///Bit 4.
12781    pub const BOTH_DIRECTIONS: Self = Self(16u32);
12782}
12783impl core::ops::BitOr for OpticalFlowSessionCreateFlagBitsNV {
12784    type Output = Self;
12785    #[inline]
12786    fn bitor(self, rhs: Self) -> Self {
12787        Self(self.0 | rhs.0)
12788    }
12789}
12790impl core::ops::BitOrAssign for OpticalFlowSessionCreateFlagBitsNV {
12791    #[inline]
12792    fn bitor_assign(&mut self, rhs: Self) {
12793        self.0 |= rhs.0;
12794    }
12795}
12796impl core::ops::BitAnd for OpticalFlowSessionCreateFlagBitsNV {
12797    type Output = Self;
12798    #[inline]
12799    fn bitand(self, rhs: Self) -> Self {
12800        Self(self.0 & rhs.0)
12801    }
12802}
12803impl core::ops::BitAndAssign for OpticalFlowSessionCreateFlagBitsNV {
12804    #[inline]
12805    fn bitand_assign(&mut self, rhs: Self) {
12806        self.0 &= rhs.0;
12807    }
12808}
12809impl core::ops::BitXor for OpticalFlowSessionCreateFlagBitsNV {
12810    type Output = Self;
12811    #[inline]
12812    fn bitxor(self, rhs: Self) -> Self {
12813        Self(self.0 ^ rhs.0)
12814    }
12815}
12816impl core::ops::BitXorAssign for OpticalFlowSessionCreateFlagBitsNV {
12817    #[inline]
12818    fn bitxor_assign(&mut self, rhs: Self) {
12819        self.0 ^= rhs.0;
12820    }
12821}
12822impl core::ops::Not for OpticalFlowSessionCreateFlagBitsNV {
12823    type Output = Self;
12824    #[inline]
12825    fn not(self) -> Self {
12826        Self(!self.0)
12827    }
12828}
12829impl core::fmt::Debug for OpticalFlowSessionCreateFlagBitsNV {
12830    #[allow(unused_mut, unused_variables)]
12831    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12832        let mut first = true;
12833        let mut remaining = self.0;
12834        if remaining & Self::ENABLE_HINT.0 != 0 {
12835            if !first {
12836                f.write_str(" | ")?;
12837            }
12838            f.write_str("ENABLE_HINT")?;
12839            remaining &= !Self::ENABLE_HINT.0;
12840            first = false;
12841        }
12842        if remaining & Self::ENABLE_COST.0 != 0 {
12843            if !first {
12844                f.write_str(" | ")?;
12845            }
12846            f.write_str("ENABLE_COST")?;
12847            remaining &= !Self::ENABLE_COST.0;
12848            first = false;
12849        }
12850        if remaining & Self::ENABLE_GLOBAL_FLOW.0 != 0 {
12851            if !first {
12852                f.write_str(" | ")?;
12853            }
12854            f.write_str("ENABLE_GLOBAL_FLOW")?;
12855            remaining &= !Self::ENABLE_GLOBAL_FLOW.0;
12856            first = false;
12857        }
12858        if remaining & Self::ALLOW_REGIONS.0 != 0 {
12859            if !first {
12860                f.write_str(" | ")?;
12861            }
12862            f.write_str("ALLOW_REGIONS")?;
12863            remaining &= !Self::ALLOW_REGIONS.0;
12864            first = false;
12865        }
12866        if remaining & Self::BOTH_DIRECTIONS.0 != 0 {
12867            if !first {
12868                f.write_str(" | ")?;
12869            }
12870            f.write_str("BOTH_DIRECTIONS")?;
12871            remaining &= !Self::BOTH_DIRECTIONS.0;
12872            first = false;
12873        }
12874        if remaining != 0u32 {
12875            if !first {
12876                f.write_str(" | ")?;
12877            }
12878            write!(f, "{:#x}", remaining)?;
12879        } else if first {
12880            f.write_str("(empty)")?;
12881        }
12882        Ok(())
12883    }
12884}
12885///[`VkOpticalFlowUsageFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowUsageFlagBitsNV.html)
12886#[repr(transparent)]
12887#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
12888#[doc(alias = "VkOpticalFlowUsageFlagBitsNV")]
12889pub struct OpticalFlowUsageFlagBitsNV(u32);
12890impl OpticalFlowUsageFlagBitsNV {
12891    #[inline]
12892    pub const fn empty() -> Self {
12893        Self(0u32)
12894    }
12895    #[inline]
12896    pub const fn from_raw(value: u32) -> Self {
12897        Self(value)
12898    }
12899    #[inline]
12900    pub const fn as_raw(self) -> u32 {
12901        self.0
12902    }
12903    #[inline]
12904    pub const fn is_empty(self) -> bool {
12905        self.0 == 0u32
12906    }
12907    #[inline]
12908    pub const fn contains(self, other: Self) -> bool {
12909        (self.0 & other.0) == other.0
12910    }
12911    pub const UNKNOWN: Self = Self(0u32);
12912    ///Bit 0.
12913    pub const INPUT: Self = Self(1u32);
12914    ///Bit 1.
12915    pub const OUTPUT: Self = Self(2u32);
12916    ///Bit 2.
12917    pub const HINT: Self = Self(4u32);
12918    ///Bit 3.
12919    pub const COST: Self = Self(8u32);
12920    ///Bit 4.
12921    pub const GLOBAL_FLOW: Self = Self(16u32);
12922}
12923impl core::ops::BitOr for OpticalFlowUsageFlagBitsNV {
12924    type Output = Self;
12925    #[inline]
12926    fn bitor(self, rhs: Self) -> Self {
12927        Self(self.0 | rhs.0)
12928    }
12929}
12930impl core::ops::BitOrAssign for OpticalFlowUsageFlagBitsNV {
12931    #[inline]
12932    fn bitor_assign(&mut self, rhs: Self) {
12933        self.0 |= rhs.0;
12934    }
12935}
12936impl core::ops::BitAnd for OpticalFlowUsageFlagBitsNV {
12937    type Output = Self;
12938    #[inline]
12939    fn bitand(self, rhs: Self) -> Self {
12940        Self(self.0 & rhs.0)
12941    }
12942}
12943impl core::ops::BitAndAssign for OpticalFlowUsageFlagBitsNV {
12944    #[inline]
12945    fn bitand_assign(&mut self, rhs: Self) {
12946        self.0 &= rhs.0;
12947    }
12948}
12949impl core::ops::BitXor for OpticalFlowUsageFlagBitsNV {
12950    type Output = Self;
12951    #[inline]
12952    fn bitxor(self, rhs: Self) -> Self {
12953        Self(self.0 ^ rhs.0)
12954    }
12955}
12956impl core::ops::BitXorAssign for OpticalFlowUsageFlagBitsNV {
12957    #[inline]
12958    fn bitxor_assign(&mut self, rhs: Self) {
12959        self.0 ^= rhs.0;
12960    }
12961}
12962impl core::ops::Not for OpticalFlowUsageFlagBitsNV {
12963    type Output = Self;
12964    #[inline]
12965    fn not(self) -> Self {
12966        Self(!self.0)
12967    }
12968}
12969impl core::fmt::Debug for OpticalFlowUsageFlagBitsNV {
12970    #[allow(unused_mut, unused_variables)]
12971    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12972        let mut first = true;
12973        let mut remaining = self.0;
12974        if remaining & Self::INPUT.0 != 0 {
12975            if !first {
12976                f.write_str(" | ")?;
12977            }
12978            f.write_str("INPUT")?;
12979            remaining &= !Self::INPUT.0;
12980            first = false;
12981        }
12982        if remaining & Self::OUTPUT.0 != 0 {
12983            if !first {
12984                f.write_str(" | ")?;
12985            }
12986            f.write_str("OUTPUT")?;
12987            remaining &= !Self::OUTPUT.0;
12988            first = false;
12989        }
12990        if remaining & Self::HINT.0 != 0 {
12991            if !first {
12992                f.write_str(" | ")?;
12993            }
12994            f.write_str("HINT")?;
12995            remaining &= !Self::HINT.0;
12996            first = false;
12997        }
12998        if remaining & Self::COST.0 != 0 {
12999            if !first {
13000                f.write_str(" | ")?;
13001            }
13002            f.write_str("COST")?;
13003            remaining &= !Self::COST.0;
13004            first = false;
13005        }
13006        if remaining & Self::GLOBAL_FLOW.0 != 0 {
13007            if !first {
13008                f.write_str(" | ")?;
13009            }
13010            f.write_str("GLOBAL_FLOW")?;
13011            remaining &= !Self::GLOBAL_FLOW.0;
13012            first = false;
13013        }
13014        if remaining != 0u32 {
13015            if !first {
13016                f.write_str(" | ")?;
13017            }
13018            write!(f, "{:#x}", remaining)?;
13019        } else if first {
13020            f.write_str("(empty)")?;
13021        }
13022        Ok(())
13023    }
13024}
13025///[`VkPartitionedAccelerationStructureInstanceFlagBitsNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstanceFlagBitsNV.html)
13026#[repr(transparent)]
13027#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13028#[doc(alias = "VkPartitionedAccelerationStructureInstanceFlagBitsNV")]
13029pub struct PartitionedAccelerationStructureInstanceFlagBitsNV(u32);
13030impl PartitionedAccelerationStructureInstanceFlagBitsNV {
13031    #[inline]
13032    pub const fn empty() -> Self {
13033        Self(0u32)
13034    }
13035    #[inline]
13036    pub const fn from_raw(value: u32) -> Self {
13037        Self(value)
13038    }
13039    #[inline]
13040    pub const fn as_raw(self) -> u32 {
13041        self.0
13042    }
13043    #[inline]
13044    pub const fn is_empty(self) -> bool {
13045        self.0 == 0u32
13046    }
13047    #[inline]
13048    pub const fn contains(self, other: Self) -> bool {
13049        (self.0 & other.0) == other.0
13050    }
13051    ///Bit 0.
13052    pub const FLAG_TRIANGLE_FACING_CULL_DISABLE: Self = Self(1u32);
13053    ///Bit 1.
13054    pub const FLAG_TRIANGLE_FLIP_FACING: Self = Self(2u32);
13055    ///Bit 2.
13056    pub const FLAG_FORCE_OPAQUE: Self = Self(4u32);
13057    ///Bit 3.
13058    pub const FLAG_FORCE_NO_OPAQUE: Self = Self(8u32);
13059    ///Bit 4.
13060    pub const FLAG_ENABLE_EXPLICIT_BOUNDING_BOX: Self = Self(16u32);
13061}
13062impl core::ops::BitOr for PartitionedAccelerationStructureInstanceFlagBitsNV {
13063    type Output = Self;
13064    #[inline]
13065    fn bitor(self, rhs: Self) -> Self {
13066        Self(self.0 | rhs.0)
13067    }
13068}
13069impl core::ops::BitOrAssign for PartitionedAccelerationStructureInstanceFlagBitsNV {
13070    #[inline]
13071    fn bitor_assign(&mut self, rhs: Self) {
13072        self.0 |= rhs.0;
13073    }
13074}
13075impl core::ops::BitAnd for PartitionedAccelerationStructureInstanceFlagBitsNV {
13076    type Output = Self;
13077    #[inline]
13078    fn bitand(self, rhs: Self) -> Self {
13079        Self(self.0 & rhs.0)
13080    }
13081}
13082impl core::ops::BitAndAssign for PartitionedAccelerationStructureInstanceFlagBitsNV {
13083    #[inline]
13084    fn bitand_assign(&mut self, rhs: Self) {
13085        self.0 &= rhs.0;
13086    }
13087}
13088impl core::ops::BitXor for PartitionedAccelerationStructureInstanceFlagBitsNV {
13089    type Output = Self;
13090    #[inline]
13091    fn bitxor(self, rhs: Self) -> Self {
13092        Self(self.0 ^ rhs.0)
13093    }
13094}
13095impl core::ops::BitXorAssign for PartitionedAccelerationStructureInstanceFlagBitsNV {
13096    #[inline]
13097    fn bitxor_assign(&mut self, rhs: Self) {
13098        self.0 ^= rhs.0;
13099    }
13100}
13101impl core::ops::Not for PartitionedAccelerationStructureInstanceFlagBitsNV {
13102    type Output = Self;
13103    #[inline]
13104    fn not(self) -> Self {
13105        Self(!self.0)
13106    }
13107}
13108impl core::fmt::Debug for PartitionedAccelerationStructureInstanceFlagBitsNV {
13109    #[allow(unused_mut, unused_variables)]
13110    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13111        let mut first = true;
13112        let mut remaining = self.0;
13113        if remaining & Self::FLAG_TRIANGLE_FACING_CULL_DISABLE.0 != 0 {
13114            if !first {
13115                f.write_str(" | ")?;
13116            }
13117            f.write_str("FLAG_TRIANGLE_FACING_CULL_DISABLE")?;
13118            remaining &= !Self::FLAG_TRIANGLE_FACING_CULL_DISABLE.0;
13119            first = false;
13120        }
13121        if remaining & Self::FLAG_TRIANGLE_FLIP_FACING.0 != 0 {
13122            if !first {
13123                f.write_str(" | ")?;
13124            }
13125            f.write_str("FLAG_TRIANGLE_FLIP_FACING")?;
13126            remaining &= !Self::FLAG_TRIANGLE_FLIP_FACING.0;
13127            first = false;
13128        }
13129        if remaining & Self::FLAG_FORCE_OPAQUE.0 != 0 {
13130            if !first {
13131                f.write_str(" | ")?;
13132            }
13133            f.write_str("FLAG_FORCE_OPAQUE")?;
13134            remaining &= !Self::FLAG_FORCE_OPAQUE.0;
13135            first = false;
13136        }
13137        if remaining & Self::FLAG_FORCE_NO_OPAQUE.0 != 0 {
13138            if !first {
13139                f.write_str(" | ")?;
13140            }
13141            f.write_str("FLAG_FORCE_NO_OPAQUE")?;
13142            remaining &= !Self::FLAG_FORCE_NO_OPAQUE.0;
13143            first = false;
13144        }
13145        if remaining & Self::FLAG_ENABLE_EXPLICIT_BOUNDING_BOX.0 != 0 {
13146            if !first {
13147                f.write_str(" | ")?;
13148            }
13149            f.write_str("FLAG_ENABLE_EXPLICIT_BOUNDING_BOX")?;
13150            remaining &= !Self::FLAG_ENABLE_EXPLICIT_BOUNDING_BOX.0;
13151            first = false;
13152        }
13153        if remaining != 0u32 {
13154            if !first {
13155                f.write_str(" | ")?;
13156            }
13157            write!(f, "{:#x}", remaining)?;
13158        } else if first {
13159            f.write_str("(empty)")?;
13160        }
13161        Ok(())
13162    }
13163}
13164///[`VkPastPresentationTimingFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingFlagBitsEXT.html)
13165#[repr(transparent)]
13166#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13167#[doc(alias = "VkPastPresentationTimingFlagBitsEXT")]
13168pub struct PastPresentationTimingFlagBitsEXT(u32);
13169impl PastPresentationTimingFlagBitsEXT {
13170    #[inline]
13171    pub const fn empty() -> Self {
13172        Self(0u32)
13173    }
13174    #[inline]
13175    pub const fn from_raw(value: u32) -> Self {
13176        Self(value)
13177    }
13178    #[inline]
13179    pub const fn as_raw(self) -> u32 {
13180        self.0
13181    }
13182    #[inline]
13183    pub const fn is_empty(self) -> bool {
13184        self.0 == 0u32
13185    }
13186    #[inline]
13187    pub const fn contains(self, other: Self) -> bool {
13188        (self.0 & other.0) == other.0
13189    }
13190    ///Bit 0.
13191    pub const ALLOW_PARTIAL_RESULTS: Self = Self(1u32);
13192    ///Bit 1.
13193    pub const ALLOW_OUT_OF_ORDER_RESULTS: Self = Self(2u32);
13194}
13195impl core::ops::BitOr for PastPresentationTimingFlagBitsEXT {
13196    type Output = Self;
13197    #[inline]
13198    fn bitor(self, rhs: Self) -> Self {
13199        Self(self.0 | rhs.0)
13200    }
13201}
13202impl core::ops::BitOrAssign for PastPresentationTimingFlagBitsEXT {
13203    #[inline]
13204    fn bitor_assign(&mut self, rhs: Self) {
13205        self.0 |= rhs.0;
13206    }
13207}
13208impl core::ops::BitAnd for PastPresentationTimingFlagBitsEXT {
13209    type Output = Self;
13210    #[inline]
13211    fn bitand(self, rhs: Self) -> Self {
13212        Self(self.0 & rhs.0)
13213    }
13214}
13215impl core::ops::BitAndAssign for PastPresentationTimingFlagBitsEXT {
13216    #[inline]
13217    fn bitand_assign(&mut self, rhs: Self) {
13218        self.0 &= rhs.0;
13219    }
13220}
13221impl core::ops::BitXor for PastPresentationTimingFlagBitsEXT {
13222    type Output = Self;
13223    #[inline]
13224    fn bitxor(self, rhs: Self) -> Self {
13225        Self(self.0 ^ rhs.0)
13226    }
13227}
13228impl core::ops::BitXorAssign for PastPresentationTimingFlagBitsEXT {
13229    #[inline]
13230    fn bitxor_assign(&mut self, rhs: Self) {
13231        self.0 ^= rhs.0;
13232    }
13233}
13234impl core::ops::Not for PastPresentationTimingFlagBitsEXT {
13235    type Output = Self;
13236    #[inline]
13237    fn not(self) -> Self {
13238        Self(!self.0)
13239    }
13240}
13241impl core::fmt::Debug for PastPresentationTimingFlagBitsEXT {
13242    #[allow(unused_mut, unused_variables)]
13243    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13244        let mut first = true;
13245        let mut remaining = self.0;
13246        if remaining & Self::ALLOW_PARTIAL_RESULTS.0 != 0 {
13247            if !first {
13248                f.write_str(" | ")?;
13249            }
13250            f.write_str("ALLOW_PARTIAL_RESULTS")?;
13251            remaining &= !Self::ALLOW_PARTIAL_RESULTS.0;
13252            first = false;
13253        }
13254        if remaining & Self::ALLOW_OUT_OF_ORDER_RESULTS.0 != 0 {
13255            if !first {
13256                f.write_str(" | ")?;
13257            }
13258            f.write_str("ALLOW_OUT_OF_ORDER_RESULTS")?;
13259            remaining &= !Self::ALLOW_OUT_OF_ORDER_RESULTS.0;
13260            first = false;
13261        }
13262        if remaining != 0u32 {
13263            if !first {
13264                f.write_str(" | ")?;
13265            }
13266            write!(f, "{:#x}", remaining)?;
13267        } else if first {
13268            f.write_str("(empty)")?;
13269        }
13270        Ok(())
13271    }
13272}
13273///[`VkPeerMemoryFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPeerMemoryFeatureFlagBits.html)
13274#[repr(transparent)]
13275#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13276#[doc(alias = "VkPeerMemoryFeatureFlagBits")]
13277pub struct PeerMemoryFeatureFlagBits(u32);
13278impl PeerMemoryFeatureFlagBits {
13279    #[inline]
13280    pub const fn empty() -> Self {
13281        Self(0u32)
13282    }
13283    #[inline]
13284    pub const fn from_raw(value: u32) -> Self {
13285        Self(value)
13286    }
13287    #[inline]
13288    pub const fn as_raw(self) -> u32 {
13289        self.0
13290    }
13291    #[inline]
13292    pub const fn is_empty(self) -> bool {
13293        self.0 == 0u32
13294    }
13295    #[inline]
13296    pub const fn contains(self, other: Self) -> bool {
13297        (self.0 & other.0) == other.0
13298    }
13299    ///Bit 0.
13300    pub const COPY_SRC: Self = Self(1u32);
13301    ///Bit 1.
13302    pub const COPY_DST: Self = Self(2u32);
13303    ///Bit 2.
13304    pub const GENERIC_SRC: Self = Self(4u32);
13305    ///Bit 3.
13306    pub const GENERIC_DST: Self = Self(8u32);
13307}
13308impl core::ops::BitOr for PeerMemoryFeatureFlagBits {
13309    type Output = Self;
13310    #[inline]
13311    fn bitor(self, rhs: Self) -> Self {
13312        Self(self.0 | rhs.0)
13313    }
13314}
13315impl core::ops::BitOrAssign for PeerMemoryFeatureFlagBits {
13316    #[inline]
13317    fn bitor_assign(&mut self, rhs: Self) {
13318        self.0 |= rhs.0;
13319    }
13320}
13321impl core::ops::BitAnd for PeerMemoryFeatureFlagBits {
13322    type Output = Self;
13323    #[inline]
13324    fn bitand(self, rhs: Self) -> Self {
13325        Self(self.0 & rhs.0)
13326    }
13327}
13328impl core::ops::BitAndAssign for PeerMemoryFeatureFlagBits {
13329    #[inline]
13330    fn bitand_assign(&mut self, rhs: Self) {
13331        self.0 &= rhs.0;
13332    }
13333}
13334impl core::ops::BitXor for PeerMemoryFeatureFlagBits {
13335    type Output = Self;
13336    #[inline]
13337    fn bitxor(self, rhs: Self) -> Self {
13338        Self(self.0 ^ rhs.0)
13339    }
13340}
13341impl core::ops::BitXorAssign for PeerMemoryFeatureFlagBits {
13342    #[inline]
13343    fn bitxor_assign(&mut self, rhs: Self) {
13344        self.0 ^= rhs.0;
13345    }
13346}
13347impl core::ops::Not for PeerMemoryFeatureFlagBits {
13348    type Output = Self;
13349    #[inline]
13350    fn not(self) -> Self {
13351        Self(!self.0)
13352    }
13353}
13354impl core::fmt::Debug for PeerMemoryFeatureFlagBits {
13355    #[allow(unused_mut, unused_variables)]
13356    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13357        let mut first = true;
13358        let mut remaining = self.0;
13359        if remaining & Self::COPY_SRC.0 != 0 {
13360            if !first {
13361                f.write_str(" | ")?;
13362            }
13363            f.write_str("COPY_SRC")?;
13364            remaining &= !Self::COPY_SRC.0;
13365            first = false;
13366        }
13367        if remaining & Self::COPY_DST.0 != 0 {
13368            if !first {
13369                f.write_str(" | ")?;
13370            }
13371            f.write_str("COPY_DST")?;
13372            remaining &= !Self::COPY_DST.0;
13373            first = false;
13374        }
13375        if remaining & Self::GENERIC_SRC.0 != 0 {
13376            if !first {
13377                f.write_str(" | ")?;
13378            }
13379            f.write_str("GENERIC_SRC")?;
13380            remaining &= !Self::GENERIC_SRC.0;
13381            first = false;
13382        }
13383        if remaining & Self::GENERIC_DST.0 != 0 {
13384            if !first {
13385                f.write_str(" | ")?;
13386            }
13387            f.write_str("GENERIC_DST")?;
13388            remaining &= !Self::GENERIC_DST.0;
13389            first = false;
13390        }
13391        if remaining != 0u32 {
13392            if !first {
13393                f.write_str(" | ")?;
13394            }
13395            write!(f, "{:#x}", remaining)?;
13396        } else if first {
13397            f.write_str("(empty)")?;
13398        }
13399        Ok(())
13400    }
13401}
13402///[`VkPerformanceCounterDescriptionFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html)
13403#[repr(transparent)]
13404#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13405#[doc(alias = "VkPerformanceCounterDescriptionFlagBitsKHR")]
13406pub struct PerformanceCounterDescriptionFlagBitsKHR(u32);
13407impl PerformanceCounterDescriptionFlagBitsKHR {
13408    #[inline]
13409    pub const fn empty() -> Self {
13410        Self(0u32)
13411    }
13412    #[inline]
13413    pub const fn from_raw(value: u32) -> Self {
13414        Self(value)
13415    }
13416    #[inline]
13417    pub const fn as_raw(self) -> u32 {
13418        self.0
13419    }
13420    #[inline]
13421    pub const fn is_empty(self) -> bool {
13422        self.0 == 0u32
13423    }
13424    #[inline]
13425    pub const fn contains(self, other: Self) -> bool {
13426        (self.0 & other.0) == other.0
13427    }
13428    ///Bit 0.
13429    pub const PERFORMANCE_IMPACTING: Self = Self(1u32);
13430    ///Bit 1.
13431    pub const CONCURRENTLY_IMPACTED: Self = Self(2u32);
13432}
13433impl core::ops::BitOr for PerformanceCounterDescriptionFlagBitsKHR {
13434    type Output = Self;
13435    #[inline]
13436    fn bitor(self, rhs: Self) -> Self {
13437        Self(self.0 | rhs.0)
13438    }
13439}
13440impl core::ops::BitOrAssign for PerformanceCounterDescriptionFlagBitsKHR {
13441    #[inline]
13442    fn bitor_assign(&mut self, rhs: Self) {
13443        self.0 |= rhs.0;
13444    }
13445}
13446impl core::ops::BitAnd for PerformanceCounterDescriptionFlagBitsKHR {
13447    type Output = Self;
13448    #[inline]
13449    fn bitand(self, rhs: Self) -> Self {
13450        Self(self.0 & rhs.0)
13451    }
13452}
13453impl core::ops::BitAndAssign for PerformanceCounterDescriptionFlagBitsKHR {
13454    #[inline]
13455    fn bitand_assign(&mut self, rhs: Self) {
13456        self.0 &= rhs.0;
13457    }
13458}
13459impl core::ops::BitXor for PerformanceCounterDescriptionFlagBitsKHR {
13460    type Output = Self;
13461    #[inline]
13462    fn bitxor(self, rhs: Self) -> Self {
13463        Self(self.0 ^ rhs.0)
13464    }
13465}
13466impl core::ops::BitXorAssign for PerformanceCounterDescriptionFlagBitsKHR {
13467    #[inline]
13468    fn bitxor_assign(&mut self, rhs: Self) {
13469        self.0 ^= rhs.0;
13470    }
13471}
13472impl core::ops::Not for PerformanceCounterDescriptionFlagBitsKHR {
13473    type Output = Self;
13474    #[inline]
13475    fn not(self) -> Self {
13476        Self(!self.0)
13477    }
13478}
13479impl core::fmt::Debug for PerformanceCounterDescriptionFlagBitsKHR {
13480    #[allow(unused_mut, unused_variables)]
13481    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13482        let mut first = true;
13483        let mut remaining = self.0;
13484        if remaining & Self::PERFORMANCE_IMPACTING.0 != 0 {
13485            if !first {
13486                f.write_str(" | ")?;
13487            }
13488            f.write_str("PERFORMANCE_IMPACTING")?;
13489            remaining &= !Self::PERFORMANCE_IMPACTING.0;
13490            first = false;
13491        }
13492        if remaining & Self::CONCURRENTLY_IMPACTED.0 != 0 {
13493            if !first {
13494                f.write_str(" | ")?;
13495            }
13496            f.write_str("CONCURRENTLY_IMPACTED")?;
13497            remaining &= !Self::CONCURRENTLY_IMPACTED.0;
13498            first = false;
13499        }
13500        if remaining != 0u32 {
13501            if !first {
13502                f.write_str(" | ")?;
13503            }
13504            write!(f, "{:#x}", remaining)?;
13505        } else if first {
13506            f.write_str("(empty)")?;
13507        }
13508        Ok(())
13509    }
13510}
13511///[`VkPhysicalDeviceSchedulingControlsFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFlagBitsARM.html)
13512#[repr(transparent)]
13513#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13514#[doc(alias = "VkPhysicalDeviceSchedulingControlsFlagBitsARM")]
13515pub struct PhysicalDeviceSchedulingControlsFlagBitsARM(u64);
13516impl PhysicalDeviceSchedulingControlsFlagBitsARM {
13517    #[inline]
13518    pub const fn empty() -> Self {
13519        Self(0u64)
13520    }
13521    #[inline]
13522    pub const fn from_raw(value: u64) -> Self {
13523        Self(value)
13524    }
13525    #[inline]
13526    pub const fn as_raw(self) -> u64 {
13527        self.0
13528    }
13529    #[inline]
13530    pub const fn is_empty(self) -> bool {
13531        self.0 == 0u64
13532    }
13533    #[inline]
13534    pub const fn contains(self, other: Self) -> bool {
13535        (self.0 & other.0) == other.0
13536    }
13537    ///Bit 0.
13538    pub const SHADER_CORE_COUNT: Self = Self(1u64);
13539}
13540impl core::ops::BitOr for PhysicalDeviceSchedulingControlsFlagBitsARM {
13541    type Output = Self;
13542    #[inline]
13543    fn bitor(self, rhs: Self) -> Self {
13544        Self(self.0 | rhs.0)
13545    }
13546}
13547impl core::ops::BitOrAssign for PhysicalDeviceSchedulingControlsFlagBitsARM {
13548    #[inline]
13549    fn bitor_assign(&mut self, rhs: Self) {
13550        self.0 |= rhs.0;
13551    }
13552}
13553impl core::ops::BitAnd for PhysicalDeviceSchedulingControlsFlagBitsARM {
13554    type Output = Self;
13555    #[inline]
13556    fn bitand(self, rhs: Self) -> Self {
13557        Self(self.0 & rhs.0)
13558    }
13559}
13560impl core::ops::BitAndAssign for PhysicalDeviceSchedulingControlsFlagBitsARM {
13561    #[inline]
13562    fn bitand_assign(&mut self, rhs: Self) {
13563        self.0 &= rhs.0;
13564    }
13565}
13566impl core::ops::BitXor for PhysicalDeviceSchedulingControlsFlagBitsARM {
13567    type Output = Self;
13568    #[inline]
13569    fn bitxor(self, rhs: Self) -> Self {
13570        Self(self.0 ^ rhs.0)
13571    }
13572}
13573impl core::ops::BitXorAssign for PhysicalDeviceSchedulingControlsFlagBitsARM {
13574    #[inline]
13575    fn bitxor_assign(&mut self, rhs: Self) {
13576        self.0 ^= rhs.0;
13577    }
13578}
13579impl core::ops::Not for PhysicalDeviceSchedulingControlsFlagBitsARM {
13580    type Output = Self;
13581    #[inline]
13582    fn not(self) -> Self {
13583        Self(!self.0)
13584    }
13585}
13586impl core::fmt::Debug for PhysicalDeviceSchedulingControlsFlagBitsARM {
13587    #[allow(unused_mut, unused_variables)]
13588    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13589        let mut first = true;
13590        let mut remaining = self.0;
13591        if remaining & Self::SHADER_CORE_COUNT.0 != 0 {
13592            if !first {
13593                f.write_str(" | ")?;
13594            }
13595            f.write_str("SHADER_CORE_COUNT")?;
13596            remaining &= !Self::SHADER_CORE_COUNT.0;
13597            first = false;
13598        }
13599        if remaining != 0u64 {
13600            if !first {
13601                f.write_str(" | ")?;
13602            }
13603            write!(f, "{:#x}", remaining)?;
13604        } else if first {
13605            f.write_str("(empty)")?;
13606        }
13607        Ok(())
13608    }
13609}
13610///[`VkPipelineCacheCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheCreateFlagBits.html)
13611#[repr(transparent)]
13612#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13613#[doc(alias = "VkPipelineCacheCreateFlagBits")]
13614pub struct PipelineCacheCreateFlagBits(u32);
13615impl PipelineCacheCreateFlagBits {
13616    #[inline]
13617    pub const fn empty() -> Self {
13618        Self(0u32)
13619    }
13620    #[inline]
13621    pub const fn from_raw(value: u32) -> Self {
13622        Self(value)
13623    }
13624    #[inline]
13625    pub const fn as_raw(self) -> u32 {
13626        self.0
13627    }
13628    #[inline]
13629    pub const fn is_empty(self) -> bool {
13630        self.0 == 0u32
13631    }
13632    #[inline]
13633    pub const fn contains(self, other: Self) -> bool {
13634        (self.0 & other.0) == other.0
13635    }
13636    ///Bit 0.
13637    pub const EXTERNALLY_SYNCHRONIZED: Self = Self(1u32);
13638    ///Bit 1.
13639    pub const READ_ONLY: Self = Self(2u32);
13640    ///Bit 2.
13641    pub const USE_APPLICATION_STORAGE: Self = Self(4u32);
13642    ///Bit 3.
13643    pub const INTERNALLY_SYNCHRONIZED_MERGE: Self = Self(8u32);
13644}
13645impl core::ops::BitOr for PipelineCacheCreateFlagBits {
13646    type Output = Self;
13647    #[inline]
13648    fn bitor(self, rhs: Self) -> Self {
13649        Self(self.0 | rhs.0)
13650    }
13651}
13652impl core::ops::BitOrAssign for PipelineCacheCreateFlagBits {
13653    #[inline]
13654    fn bitor_assign(&mut self, rhs: Self) {
13655        self.0 |= rhs.0;
13656    }
13657}
13658impl core::ops::BitAnd for PipelineCacheCreateFlagBits {
13659    type Output = Self;
13660    #[inline]
13661    fn bitand(self, rhs: Self) -> Self {
13662        Self(self.0 & rhs.0)
13663    }
13664}
13665impl core::ops::BitAndAssign for PipelineCacheCreateFlagBits {
13666    #[inline]
13667    fn bitand_assign(&mut self, rhs: Self) {
13668        self.0 &= rhs.0;
13669    }
13670}
13671impl core::ops::BitXor for PipelineCacheCreateFlagBits {
13672    type Output = Self;
13673    #[inline]
13674    fn bitxor(self, rhs: Self) -> Self {
13675        Self(self.0 ^ rhs.0)
13676    }
13677}
13678impl core::ops::BitXorAssign for PipelineCacheCreateFlagBits {
13679    #[inline]
13680    fn bitxor_assign(&mut self, rhs: Self) {
13681        self.0 ^= rhs.0;
13682    }
13683}
13684impl core::ops::Not for PipelineCacheCreateFlagBits {
13685    type Output = Self;
13686    #[inline]
13687    fn not(self) -> Self {
13688        Self(!self.0)
13689    }
13690}
13691impl core::fmt::Debug for PipelineCacheCreateFlagBits {
13692    #[allow(unused_mut, unused_variables)]
13693    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13694        let mut first = true;
13695        let mut remaining = self.0;
13696        if remaining & Self::EXTERNALLY_SYNCHRONIZED.0 != 0 {
13697            if !first {
13698                f.write_str(" | ")?;
13699            }
13700            f.write_str("EXTERNALLY_SYNCHRONIZED")?;
13701            remaining &= !Self::EXTERNALLY_SYNCHRONIZED.0;
13702            first = false;
13703        }
13704        if remaining & Self::READ_ONLY.0 != 0 {
13705            if !first {
13706                f.write_str(" | ")?;
13707            }
13708            f.write_str("READ_ONLY")?;
13709            remaining &= !Self::READ_ONLY.0;
13710            first = false;
13711        }
13712        if remaining & Self::USE_APPLICATION_STORAGE.0 != 0 {
13713            if !first {
13714                f.write_str(" | ")?;
13715            }
13716            f.write_str("USE_APPLICATION_STORAGE")?;
13717            remaining &= !Self::USE_APPLICATION_STORAGE.0;
13718            first = false;
13719        }
13720        if remaining & Self::INTERNALLY_SYNCHRONIZED_MERGE.0 != 0 {
13721            if !first {
13722                f.write_str(" | ")?;
13723            }
13724            f.write_str("INTERNALLY_SYNCHRONIZED_MERGE")?;
13725            remaining &= !Self::INTERNALLY_SYNCHRONIZED_MERGE.0;
13726            first = false;
13727        }
13728        if remaining != 0u32 {
13729            if !first {
13730                f.write_str(" | ")?;
13731            }
13732            write!(f, "{:#x}", remaining)?;
13733        } else if first {
13734            f.write_str("(empty)")?;
13735        }
13736        Ok(())
13737    }
13738}
13739///[`VkPipelineColorBlendStateCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateFlagBits.html)
13740#[repr(transparent)]
13741#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13742#[doc(alias = "VkPipelineColorBlendStateCreateFlagBits")]
13743pub struct PipelineColorBlendStateCreateFlagBits(u32);
13744impl PipelineColorBlendStateCreateFlagBits {
13745    #[inline]
13746    pub const fn empty() -> Self {
13747        Self(0u32)
13748    }
13749    #[inline]
13750    pub const fn from_raw(value: u32) -> Self {
13751        Self(value)
13752    }
13753    #[inline]
13754    pub const fn as_raw(self) -> u32 {
13755        self.0
13756    }
13757    #[inline]
13758    pub const fn is_empty(self) -> bool {
13759        self.0 == 0u32
13760    }
13761    #[inline]
13762    pub const fn contains(self, other: Self) -> bool {
13763        (self.0 & other.0) == other.0
13764    }
13765    pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS;
13766    ///Bit 0.
13767    pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS: Self = Self(1u32);
13768}
13769impl core::ops::BitOr for PipelineColorBlendStateCreateFlagBits {
13770    type Output = Self;
13771    #[inline]
13772    fn bitor(self, rhs: Self) -> Self {
13773        Self(self.0 | rhs.0)
13774    }
13775}
13776impl core::ops::BitOrAssign for PipelineColorBlendStateCreateFlagBits {
13777    #[inline]
13778    fn bitor_assign(&mut self, rhs: Self) {
13779        self.0 |= rhs.0;
13780    }
13781}
13782impl core::ops::BitAnd for PipelineColorBlendStateCreateFlagBits {
13783    type Output = Self;
13784    #[inline]
13785    fn bitand(self, rhs: Self) -> Self {
13786        Self(self.0 & rhs.0)
13787    }
13788}
13789impl core::ops::BitAndAssign for PipelineColorBlendStateCreateFlagBits {
13790    #[inline]
13791    fn bitand_assign(&mut self, rhs: Self) {
13792        self.0 &= rhs.0;
13793    }
13794}
13795impl core::ops::BitXor for PipelineColorBlendStateCreateFlagBits {
13796    type Output = Self;
13797    #[inline]
13798    fn bitxor(self, rhs: Self) -> Self {
13799        Self(self.0 ^ rhs.0)
13800    }
13801}
13802impl core::ops::BitXorAssign for PipelineColorBlendStateCreateFlagBits {
13803    #[inline]
13804    fn bitxor_assign(&mut self, rhs: Self) {
13805        self.0 ^= rhs.0;
13806    }
13807}
13808impl core::ops::Not for PipelineColorBlendStateCreateFlagBits {
13809    type Output = Self;
13810    #[inline]
13811    fn not(self) -> Self {
13812        Self(!self.0)
13813    }
13814}
13815impl core::fmt::Debug for PipelineColorBlendStateCreateFlagBits {
13816    #[allow(unused_mut, unused_variables)]
13817    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13818        let mut first = true;
13819        let mut remaining = self.0;
13820        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS.0 != 0 {
13821            if !first {
13822                f.write_str(" | ")?;
13823            }
13824            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_ACCESS")?;
13825            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS.0;
13826            first = false;
13827        }
13828        if remaining != 0u32 {
13829            if !first {
13830                f.write_str(" | ")?;
13831            }
13832            write!(f, "{:#x}", remaining)?;
13833        } else if first {
13834            f.write_str("(empty)")?;
13835        }
13836        Ok(())
13837    }
13838}
13839///[`VkPipelineCompilerControlFlagBitsAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCompilerControlFlagBitsAMD.html)
13840#[repr(transparent)]
13841#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13842#[doc(alias = "VkPipelineCompilerControlFlagBitsAMD")]
13843pub struct PipelineCompilerControlFlagBitsAMD(u32);
13844impl PipelineCompilerControlFlagBitsAMD {
13845    #[inline]
13846    pub const fn empty() -> Self {
13847        Self(0u32)
13848    }
13849    #[inline]
13850    pub const fn from_raw(value: u32) -> Self {
13851        Self(value)
13852    }
13853    #[inline]
13854    pub const fn as_raw(self) -> u32 {
13855        self.0
13856    }
13857    #[inline]
13858    pub const fn is_empty(self) -> bool {
13859        self.0 == 0u32
13860    }
13861    #[inline]
13862    pub const fn contains(self, other: Self) -> bool {
13863        (self.0 & other.0) == other.0
13864    }
13865}
13866impl core::ops::BitOr for PipelineCompilerControlFlagBitsAMD {
13867    type Output = Self;
13868    #[inline]
13869    fn bitor(self, rhs: Self) -> Self {
13870        Self(self.0 | rhs.0)
13871    }
13872}
13873impl core::ops::BitOrAssign for PipelineCompilerControlFlagBitsAMD {
13874    #[inline]
13875    fn bitor_assign(&mut self, rhs: Self) {
13876        self.0 |= rhs.0;
13877    }
13878}
13879impl core::ops::BitAnd for PipelineCompilerControlFlagBitsAMD {
13880    type Output = Self;
13881    #[inline]
13882    fn bitand(self, rhs: Self) -> Self {
13883        Self(self.0 & rhs.0)
13884    }
13885}
13886impl core::ops::BitAndAssign for PipelineCompilerControlFlagBitsAMD {
13887    #[inline]
13888    fn bitand_assign(&mut self, rhs: Self) {
13889        self.0 &= rhs.0;
13890    }
13891}
13892impl core::ops::BitXor for PipelineCompilerControlFlagBitsAMD {
13893    type Output = Self;
13894    #[inline]
13895    fn bitxor(self, rhs: Self) -> Self {
13896        Self(self.0 ^ rhs.0)
13897    }
13898}
13899impl core::ops::BitXorAssign for PipelineCompilerControlFlagBitsAMD {
13900    #[inline]
13901    fn bitxor_assign(&mut self, rhs: Self) {
13902        self.0 ^= rhs.0;
13903    }
13904}
13905impl core::ops::Not for PipelineCompilerControlFlagBitsAMD {
13906    type Output = Self;
13907    #[inline]
13908    fn not(self) -> Self {
13909        Self(!self.0)
13910    }
13911}
13912impl core::fmt::Debug for PipelineCompilerControlFlagBitsAMD {
13913    #[allow(unused_mut, unused_variables)]
13914    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
13915        let mut first = true;
13916        let mut remaining = self.0;
13917        if remaining != 0u32 {
13918            if !first {
13919                f.write_str(" | ")?;
13920            }
13921            write!(f, "{:#x}", remaining)?;
13922        } else if first {
13923            f.write_str("(empty)")?;
13924        }
13925        Ok(())
13926    }
13927}
13928///[`VkPipelineCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits.html)
13929#[repr(transparent)]
13930#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
13931#[doc(alias = "VkPipelineCreateFlagBits")]
13932pub struct PipelineCreateFlagBits(u32);
13933impl PipelineCreateFlagBits {
13934    #[inline]
13935    pub const fn empty() -> Self {
13936        Self(0u32)
13937    }
13938    #[inline]
13939    pub const fn from_raw(value: u32) -> Self {
13940        Self(value)
13941    }
13942    #[inline]
13943    pub const fn as_raw(self) -> u32 {
13944        self.0
13945    }
13946    #[inline]
13947    pub const fn is_empty(self) -> bool {
13948        self.0 == 0u32
13949    }
13950    #[inline]
13951    pub const fn contains(self, other: Self) -> bool {
13952        (self.0 & other.0) == other.0
13953    }
13954    ///Bit 0.
13955    pub const DISABLE_OPTIMIZATION: Self = Self(1u32);
13956    ///Bit 1.
13957    pub const ALLOW_DERIVATIVES: Self = Self(2u32);
13958    ///Bit 2.
13959    pub const DERIVATIVE: Self = Self(4u32);
13960    ///Bit 4.
13961    pub const DISPATCH_BASE: Self = Self(16u32);
13962    ///Bit 3.
13963    pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(8u32);
13964    ///Bit 8.
13965    pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(256u32);
13966    ///Bit 9.
13967    pub const EARLY_RETURN_ON_FAILURE: Self = Self(512u32);
13968    ///Bit 27.
13969    pub const NO_PROTECTED_ACCESS: Self = Self(134217728u32);
13970    ///Bit 30.
13971    pub const PROTECTED_ACCESS_ONLY: Self = Self(1073741824u32);
13972    ///Bit 14.
13973    pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS: Self = Self(16384u32);
13974    ///Bit 15.
13975    pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS: Self = Self(32768u32);
13976    ///Bit 16.
13977    pub const RAY_TRACING_NO_NULL_MISS_SHADERS: Self = Self(65536u32);
13978    ///Bit 17.
13979    pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS: Self = Self(131072u32);
13980    ///Bit 12.
13981    pub const RAY_TRACING_SKIP_TRIANGLES: Self = Self(4096u32);
13982    ///Bit 13.
13983    pub const RAY_TRACING_SKIP_AABBS: Self = Self(8192u32);
13984    ///Bit 19.
13985    pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY: Self = Self(524288u32);
13986    ///Bit 5.
13987    pub const DEFER_COMPILE: Self = Self(32u32);
13988    ///Bit 22.
13989    pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(4194304u32);
13990    pub const PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT;
13991    ///Bit 21.
13992    pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(2097152u32);
13993    pub const PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT;
13994    ///Bit 6.
13995    pub const CAPTURE_STATISTICS: Self = Self(64u32);
13996    ///Bit 7.
13997    pub const CAPTURE_INTERNAL_REPRESENTATIONS: Self = Self(128u32);
13998    ///Bit 18.
13999    pub const INDIRECT_BINDABLE: Self = Self(262144u32);
14000    ///Bit 11.
14001    pub const LIBRARY: Self = Self(2048u32);
14002    ///Bit 29.
14003    pub const DESCRIPTOR_BUFFER: Self = Self(536870912u32);
14004    ///Bit 23.
14005    pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO: Self = Self(8388608u32);
14006    ///Bit 10.
14007    pub const LINK_TIME_OPTIMIZATION: Self = Self(1024u32);
14008    ///Bit 20.
14009    pub const RAY_TRACING_ALLOW_MOTION: Self = Self(1048576u32);
14010    ///Bit 25.
14011    pub const COLOR_ATTACHMENT_FEEDBACK_LOOP: Self = Self(33554432u32);
14012    ///Bit 26.
14013    pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP: Self = Self(67108864u32);
14014    ///Bit 24.
14015    pub const RAY_TRACING_OPACITY_MICROMAP: Self = Self(16777216u32);
14016    ///Bit 28.
14017    pub const RAY_TRACING_DISPLACEMENT_MICROMAP: Self = Self(268435456u32);
14018}
14019impl core::ops::BitOr for PipelineCreateFlagBits {
14020    type Output = Self;
14021    #[inline]
14022    fn bitor(self, rhs: Self) -> Self {
14023        Self(self.0 | rhs.0)
14024    }
14025}
14026impl core::ops::BitOrAssign for PipelineCreateFlagBits {
14027    #[inline]
14028    fn bitor_assign(&mut self, rhs: Self) {
14029        self.0 |= rhs.0;
14030    }
14031}
14032impl core::ops::BitAnd for PipelineCreateFlagBits {
14033    type Output = Self;
14034    #[inline]
14035    fn bitand(self, rhs: Self) -> Self {
14036        Self(self.0 & rhs.0)
14037    }
14038}
14039impl core::ops::BitAndAssign for PipelineCreateFlagBits {
14040    #[inline]
14041    fn bitand_assign(&mut self, rhs: Self) {
14042        self.0 &= rhs.0;
14043    }
14044}
14045impl core::ops::BitXor for PipelineCreateFlagBits {
14046    type Output = Self;
14047    #[inline]
14048    fn bitxor(self, rhs: Self) -> Self {
14049        Self(self.0 ^ rhs.0)
14050    }
14051}
14052impl core::ops::BitXorAssign for PipelineCreateFlagBits {
14053    #[inline]
14054    fn bitxor_assign(&mut self, rhs: Self) {
14055        self.0 ^= rhs.0;
14056    }
14057}
14058impl core::ops::Not for PipelineCreateFlagBits {
14059    type Output = Self;
14060    #[inline]
14061    fn not(self) -> Self {
14062        Self(!self.0)
14063    }
14064}
14065impl core::fmt::Debug for PipelineCreateFlagBits {
14066    #[allow(unused_mut, unused_variables)]
14067    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
14068        let mut first = true;
14069        let mut remaining = self.0;
14070        if remaining & Self::DISABLE_OPTIMIZATION.0 != 0 {
14071            if !first {
14072                f.write_str(" | ")?;
14073            }
14074            f.write_str("DISABLE_OPTIMIZATION")?;
14075            remaining &= !Self::DISABLE_OPTIMIZATION.0;
14076            first = false;
14077        }
14078        if remaining & Self::ALLOW_DERIVATIVES.0 != 0 {
14079            if !first {
14080                f.write_str(" | ")?;
14081            }
14082            f.write_str("ALLOW_DERIVATIVES")?;
14083            remaining &= !Self::ALLOW_DERIVATIVES.0;
14084            first = false;
14085        }
14086        if remaining & Self::DERIVATIVE.0 != 0 {
14087            if !first {
14088                f.write_str(" | ")?;
14089            }
14090            f.write_str("DERIVATIVE")?;
14091            remaining &= !Self::DERIVATIVE.0;
14092            first = false;
14093        }
14094        if remaining & Self::DISPATCH_BASE.0 != 0 {
14095            if !first {
14096                f.write_str(" | ")?;
14097            }
14098            f.write_str("DISPATCH_BASE")?;
14099            remaining &= !Self::DISPATCH_BASE.0;
14100            first = false;
14101        }
14102        if remaining & Self::VIEW_INDEX_FROM_DEVICE_INDEX.0 != 0 {
14103            if !first {
14104                f.write_str(" | ")?;
14105            }
14106            f.write_str("VIEW_INDEX_FROM_DEVICE_INDEX")?;
14107            remaining &= !Self::VIEW_INDEX_FROM_DEVICE_INDEX.0;
14108            first = false;
14109        }
14110        if remaining & Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0 != 0 {
14111            if !first {
14112                f.write_str(" | ")?;
14113            }
14114            f.write_str("FAIL_ON_PIPELINE_COMPILE_REQUIRED")?;
14115            remaining &= !Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0;
14116            first = false;
14117        }
14118        if remaining & Self::EARLY_RETURN_ON_FAILURE.0 != 0 {
14119            if !first {
14120                f.write_str(" | ")?;
14121            }
14122            f.write_str("EARLY_RETURN_ON_FAILURE")?;
14123            remaining &= !Self::EARLY_RETURN_ON_FAILURE.0;
14124            first = false;
14125        }
14126        if remaining & Self::NO_PROTECTED_ACCESS.0 != 0 {
14127            if !first {
14128                f.write_str(" | ")?;
14129            }
14130            f.write_str("NO_PROTECTED_ACCESS")?;
14131            remaining &= !Self::NO_PROTECTED_ACCESS.0;
14132            first = false;
14133        }
14134        if remaining & Self::PROTECTED_ACCESS_ONLY.0 != 0 {
14135            if !first {
14136                f.write_str(" | ")?;
14137            }
14138            f.write_str("PROTECTED_ACCESS_ONLY")?;
14139            remaining &= !Self::PROTECTED_ACCESS_ONLY.0;
14140            first = false;
14141        }
14142        if remaining & Self::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0 != 0 {
14143            if !first {
14144                f.write_str(" | ")?;
14145            }
14146            f.write_str("RAY_TRACING_NO_NULL_ANY_HIT_SHADERS")?;
14147            remaining &= !Self::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0;
14148            first = false;
14149        }
14150        if remaining & Self::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0 != 0 {
14151            if !first {
14152                f.write_str(" | ")?;
14153            }
14154            f.write_str("RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS")?;
14155            remaining &= !Self::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0;
14156            first = false;
14157        }
14158        if remaining & Self::RAY_TRACING_NO_NULL_MISS_SHADERS.0 != 0 {
14159            if !first {
14160                f.write_str(" | ")?;
14161            }
14162            f.write_str("RAY_TRACING_NO_NULL_MISS_SHADERS")?;
14163            remaining &= !Self::RAY_TRACING_NO_NULL_MISS_SHADERS.0;
14164            first = false;
14165        }
14166        if remaining & Self::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0 != 0 {
14167            if !first {
14168                f.write_str(" | ")?;
14169            }
14170            f.write_str("RAY_TRACING_NO_NULL_INTERSECTION_SHADERS")?;
14171            remaining &= !Self::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0;
14172            first = false;
14173        }
14174        if remaining & Self::RAY_TRACING_SKIP_TRIANGLES.0 != 0 {
14175            if !first {
14176                f.write_str(" | ")?;
14177            }
14178            f.write_str("RAY_TRACING_SKIP_TRIANGLES")?;
14179            remaining &= !Self::RAY_TRACING_SKIP_TRIANGLES.0;
14180            first = false;
14181        }
14182        if remaining & Self::RAY_TRACING_SKIP_AABBS.0 != 0 {
14183            if !first {
14184                f.write_str(" | ")?;
14185            }
14186            f.write_str("RAY_TRACING_SKIP_AABBS")?;
14187            remaining &= !Self::RAY_TRACING_SKIP_AABBS.0;
14188            first = false;
14189        }
14190        if remaining & Self::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0 != 0 {
14191            if !first {
14192                f.write_str(" | ")?;
14193            }
14194            f.write_str("RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY")?;
14195            remaining &= !Self::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0;
14196            first = false;
14197        }
14198        if remaining & Self::DEFER_COMPILE.0 != 0 {
14199            if !first {
14200                f.write_str(" | ")?;
14201            }
14202            f.write_str("DEFER_COMPILE")?;
14203            remaining &= !Self::DEFER_COMPILE.0;
14204            first = false;
14205        }
14206        if remaining & Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0 != 0 {
14207            if !first {
14208                f.write_str(" | ")?;
14209            }
14210            f.write_str("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT")?;
14211            remaining &= !Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0;
14212            first = false;
14213        }
14214        if remaining & Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
14215            if !first {
14216                f.write_str(" | ")?;
14217            }
14218            f.write_str("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT")?;
14219            remaining &= !Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0;
14220            first = false;
14221        }
14222        if remaining & Self::CAPTURE_STATISTICS.0 != 0 {
14223            if !first {
14224                f.write_str(" | ")?;
14225            }
14226            f.write_str("CAPTURE_STATISTICS")?;
14227            remaining &= !Self::CAPTURE_STATISTICS.0;
14228            first = false;
14229        }
14230        if remaining & Self::CAPTURE_INTERNAL_REPRESENTATIONS.0 != 0 {
14231            if !first {
14232                f.write_str(" | ")?;
14233            }
14234            f.write_str("CAPTURE_INTERNAL_REPRESENTATIONS")?;
14235            remaining &= !Self::CAPTURE_INTERNAL_REPRESENTATIONS.0;
14236            first = false;
14237        }
14238        if remaining & Self::INDIRECT_BINDABLE.0 != 0 {
14239            if !first {
14240                f.write_str(" | ")?;
14241            }
14242            f.write_str("INDIRECT_BINDABLE")?;
14243            remaining &= !Self::INDIRECT_BINDABLE.0;
14244            first = false;
14245        }
14246        if remaining & Self::LIBRARY.0 != 0 {
14247            if !first {
14248                f.write_str(" | ")?;
14249            }
14250            f.write_str("LIBRARY")?;
14251            remaining &= !Self::LIBRARY.0;
14252            first = false;
14253        }
14254        if remaining & Self::DESCRIPTOR_BUFFER.0 != 0 {
14255            if !first {
14256                f.write_str(" | ")?;
14257            }
14258            f.write_str("DESCRIPTOR_BUFFER")?;
14259            remaining &= !Self::DESCRIPTOR_BUFFER.0;
14260            first = false;
14261        }
14262        if remaining & Self::RETAIN_LINK_TIME_OPTIMIZATION_INFO.0 != 0 {
14263            if !first {
14264                f.write_str(" | ")?;
14265            }
14266            f.write_str("RETAIN_LINK_TIME_OPTIMIZATION_INFO")?;
14267            remaining &= !Self::RETAIN_LINK_TIME_OPTIMIZATION_INFO.0;
14268            first = false;
14269        }
14270        if remaining & Self::LINK_TIME_OPTIMIZATION.0 != 0 {
14271            if !first {
14272                f.write_str(" | ")?;
14273            }
14274            f.write_str("LINK_TIME_OPTIMIZATION")?;
14275            remaining &= !Self::LINK_TIME_OPTIMIZATION.0;
14276            first = false;
14277        }
14278        if remaining & Self::RAY_TRACING_ALLOW_MOTION.0 != 0 {
14279            if !first {
14280                f.write_str(" | ")?;
14281            }
14282            f.write_str("RAY_TRACING_ALLOW_MOTION")?;
14283            remaining &= !Self::RAY_TRACING_ALLOW_MOTION.0;
14284            first = false;
14285        }
14286        if remaining & Self::COLOR_ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
14287            if !first {
14288                f.write_str(" | ")?;
14289            }
14290            f.write_str("COLOR_ATTACHMENT_FEEDBACK_LOOP")?;
14291            remaining &= !Self::COLOR_ATTACHMENT_FEEDBACK_LOOP.0;
14292            first = false;
14293        }
14294        if remaining & Self::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
14295            if !first {
14296                f.write_str(" | ")?;
14297            }
14298            f.write_str("DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP")?;
14299            remaining &= !Self::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0;
14300            first = false;
14301        }
14302        if remaining & Self::RAY_TRACING_OPACITY_MICROMAP.0 != 0 {
14303            if !first {
14304                f.write_str(" | ")?;
14305            }
14306            f.write_str("RAY_TRACING_OPACITY_MICROMAP")?;
14307            remaining &= !Self::RAY_TRACING_OPACITY_MICROMAP.0;
14308            first = false;
14309        }
14310        if remaining & Self::RAY_TRACING_DISPLACEMENT_MICROMAP.0 != 0 {
14311            if !first {
14312                f.write_str(" | ")?;
14313            }
14314            f.write_str("RAY_TRACING_DISPLACEMENT_MICROMAP")?;
14315            remaining &= !Self::RAY_TRACING_DISPLACEMENT_MICROMAP.0;
14316            first = false;
14317        }
14318        if remaining != 0u32 {
14319            if !first {
14320                f.write_str(" | ")?;
14321            }
14322            write!(f, "{:#x}", remaining)?;
14323        } else if first {
14324            f.write_str("(empty)")?;
14325        }
14326        Ok(())
14327    }
14328}
14329///[`VkPipelineCreateFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits2.html)
14330#[repr(transparent)]
14331#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
14332#[doc(alias = "VkPipelineCreateFlagBits2")]
14333pub struct PipelineCreateFlagBits2(u64);
14334impl PipelineCreateFlagBits2 {
14335    #[inline]
14336    pub const fn empty() -> Self {
14337        Self(0u64)
14338    }
14339    #[inline]
14340    pub const fn from_raw(value: u64) -> Self {
14341        Self(value)
14342    }
14343    #[inline]
14344    pub const fn as_raw(self) -> u64 {
14345        self.0
14346    }
14347    #[inline]
14348    pub const fn is_empty(self) -> bool {
14349        self.0 == 0u64
14350    }
14351    #[inline]
14352    pub const fn contains(self, other: Self) -> bool {
14353        (self.0 & other.0) == other.0
14354    }
14355    ///Bit 0.
14356    pub const _2_DISABLE_OPTIMIZATION: Self = Self(1u64);
14357    ///Bit 1.
14358    pub const _2_ALLOW_DERIVATIVES: Self = Self(2u64);
14359    ///Bit 2.
14360    pub const _2_DERIVATIVE: Self = Self(4u64);
14361    ///Bit 3.
14362    pub const _2_VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(8u64);
14363    ///Bit 4.
14364    pub const _2_DISPATCH_BASE: Self = Self(16u64);
14365    ///Bit 8.
14366    pub const _2_FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(256u64);
14367    ///Bit 9.
14368    pub const _2_EARLY_RETURN_ON_FAILURE: Self = Self(512u64);
14369    ///Bit 27.
14370    pub const _2_NO_PROTECTED_ACCESS: Self = Self(134217728u64);
14371    ///Bit 30.
14372    pub const _2_PROTECTED_ACCESS_ONLY: Self = Self(1073741824u64);
14373    ///Bit 32.
14374    pub const _2_EXECUTION_GRAPH_BIT: Self = Self(4294967296u64);
14375    ///Bit 36.
14376    pub const _2_DESCRIPTOR_HEAP: Self = Self(68719476736u64);
14377    pub const _2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES: Self = Self::_2_RAY_TRACING_SKIP_TRIANGLES;
14378    ///Bit 33.
14379    pub const _2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES: Self = Self(
14380        8589934592u64,
14381    );
14382    ///Bit 34.
14383    pub const _2_ENABLE_LEGACY_DITHERING: Self = Self(17179869184u64);
14384    ///Bit 5.
14385    pub const _2_DEFER_COMPILE: Self = Self(32u64);
14386    ///Bit 6.
14387    pub const _2_CAPTURE_STATISTICS: Self = Self(64u64);
14388    ///Bit 7.
14389    pub const _2_CAPTURE_INTERNAL_REPRESENTATIONS: Self = Self(128u64);
14390    ///Bit 10.
14391    pub const _2_LINK_TIME_OPTIMIZATION: Self = Self(1024u64);
14392    ///Bit 23.
14393    pub const _2_RETAIN_LINK_TIME_OPTIMIZATION_INFO: Self = Self(8388608u64);
14394    ///Bit 11.
14395    pub const _2_LIBRARY: Self = Self(2048u64);
14396    ///Bit 12.
14397    pub const _2_RAY_TRACING_SKIP_TRIANGLES: Self = Self(4096u64);
14398    ///Bit 13.
14399    pub const _2_RAY_TRACING_SKIP_AABBS: Self = Self(8192u64);
14400    ///Bit 14.
14401    pub const _2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS: Self = Self(16384u64);
14402    ///Bit 15.
14403    pub const _2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS: Self = Self(32768u64);
14404    ///Bit 16.
14405    pub const _2_RAY_TRACING_NO_NULL_MISS_SHADERS: Self = Self(65536u64);
14406    ///Bit 17.
14407    pub const _2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS: Self = Self(131072u64);
14408    ///Bit 19.
14409    pub const _2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY: Self = Self(524288u64);
14410    ///Bit 18.
14411    pub const _2_INDIRECT_BINDABLE: Self = Self(262144u64);
14412    ///Bit 20.
14413    pub const _2_RAY_TRACING_ALLOW_MOTION: Self = Self(1048576u64);
14414    ///Bit 21.
14415    pub const _2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(2097152u64);
14416    ///Bit 22.
14417    pub const _2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(4194304u64);
14418    ///Bit 24.
14419    pub const _2_RAY_TRACING_OPACITY_MICROMAP: Self = Self(16777216u64);
14420    ///Bit 25.
14421    pub const _2_COLOR_ATTACHMENT_FEEDBACK_LOOP: Self = Self(33554432u64);
14422    ///Bit 26.
14423    pub const _2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP: Self = Self(67108864u64);
14424    ///Bit 28.
14425    pub const _2_RAY_TRACING_DISPLACEMENT_MICROMAP: Self = Self(268435456u64);
14426    ///Bit 29.
14427    pub const _2_DESCRIPTOR_BUFFER: Self = Self(536870912u64);
14428    ///Bit 37.
14429    pub const _2_DISALLOW_OPACITY_MICROMAP_BIT: Self = Self(137438953472u64);
14430    ///Bit 39.
14431    pub const _2_INSTRUMENT_SHADERS_BIT: Self = Self(549755813888u64);
14432    ///Bit 31.
14433    pub const _2_CAPTURE_DATA: Self = Self(2147483648u64);
14434    ///Bit 40.
14435    pub const _2_PER_LAYER_FRAGMENT_DENSITY_BIT: Self = Self(1099511627776u64);
14436    ///Bit 43.
14437    pub const _2_64_BIT_INDEXING: Self = Self(8796093022208u64);
14438}
14439impl core::ops::BitOr for PipelineCreateFlagBits2 {
14440    type Output = Self;
14441    #[inline]
14442    fn bitor(self, rhs: Self) -> Self {
14443        Self(self.0 | rhs.0)
14444    }
14445}
14446impl core::ops::BitOrAssign for PipelineCreateFlagBits2 {
14447    #[inline]
14448    fn bitor_assign(&mut self, rhs: Self) {
14449        self.0 |= rhs.0;
14450    }
14451}
14452impl core::ops::BitAnd for PipelineCreateFlagBits2 {
14453    type Output = Self;
14454    #[inline]
14455    fn bitand(self, rhs: Self) -> Self {
14456        Self(self.0 & rhs.0)
14457    }
14458}
14459impl core::ops::BitAndAssign for PipelineCreateFlagBits2 {
14460    #[inline]
14461    fn bitand_assign(&mut self, rhs: Self) {
14462        self.0 &= rhs.0;
14463    }
14464}
14465impl core::ops::BitXor for PipelineCreateFlagBits2 {
14466    type Output = Self;
14467    #[inline]
14468    fn bitxor(self, rhs: Self) -> Self {
14469        Self(self.0 ^ rhs.0)
14470    }
14471}
14472impl core::ops::BitXorAssign for PipelineCreateFlagBits2 {
14473    #[inline]
14474    fn bitxor_assign(&mut self, rhs: Self) {
14475        self.0 ^= rhs.0;
14476    }
14477}
14478impl core::ops::Not for PipelineCreateFlagBits2 {
14479    type Output = Self;
14480    #[inline]
14481    fn not(self) -> Self {
14482        Self(!self.0)
14483    }
14484}
14485impl core::fmt::Debug for PipelineCreateFlagBits2 {
14486    #[allow(unused_mut, unused_variables)]
14487    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
14488        let mut first = true;
14489        let mut remaining = self.0;
14490        if remaining & Self::_2_DISABLE_OPTIMIZATION.0 != 0 {
14491            if !first {
14492                f.write_str(" | ")?;
14493            }
14494            f.write_str("_2_DISABLE_OPTIMIZATION")?;
14495            remaining &= !Self::_2_DISABLE_OPTIMIZATION.0;
14496            first = false;
14497        }
14498        if remaining & Self::_2_ALLOW_DERIVATIVES.0 != 0 {
14499            if !first {
14500                f.write_str(" | ")?;
14501            }
14502            f.write_str("_2_ALLOW_DERIVATIVES")?;
14503            remaining &= !Self::_2_ALLOW_DERIVATIVES.0;
14504            first = false;
14505        }
14506        if remaining & Self::_2_DERIVATIVE.0 != 0 {
14507            if !first {
14508                f.write_str(" | ")?;
14509            }
14510            f.write_str("_2_DERIVATIVE")?;
14511            remaining &= !Self::_2_DERIVATIVE.0;
14512            first = false;
14513        }
14514        if remaining & Self::_2_VIEW_INDEX_FROM_DEVICE_INDEX.0 != 0 {
14515            if !first {
14516                f.write_str(" | ")?;
14517            }
14518            f.write_str("_2_VIEW_INDEX_FROM_DEVICE_INDEX")?;
14519            remaining &= !Self::_2_VIEW_INDEX_FROM_DEVICE_INDEX.0;
14520            first = false;
14521        }
14522        if remaining & Self::_2_DISPATCH_BASE.0 != 0 {
14523            if !first {
14524                f.write_str(" | ")?;
14525            }
14526            f.write_str("_2_DISPATCH_BASE")?;
14527            remaining &= !Self::_2_DISPATCH_BASE.0;
14528            first = false;
14529        }
14530        if remaining & Self::_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED.0 != 0 {
14531            if !first {
14532                f.write_str(" | ")?;
14533            }
14534            f.write_str("_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED")?;
14535            remaining &= !Self::_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED.0;
14536            first = false;
14537        }
14538        if remaining & Self::_2_EARLY_RETURN_ON_FAILURE.0 != 0 {
14539            if !first {
14540                f.write_str(" | ")?;
14541            }
14542            f.write_str("_2_EARLY_RETURN_ON_FAILURE")?;
14543            remaining &= !Self::_2_EARLY_RETURN_ON_FAILURE.0;
14544            first = false;
14545        }
14546        if remaining & Self::_2_NO_PROTECTED_ACCESS.0 != 0 {
14547            if !first {
14548                f.write_str(" | ")?;
14549            }
14550            f.write_str("_2_NO_PROTECTED_ACCESS")?;
14551            remaining &= !Self::_2_NO_PROTECTED_ACCESS.0;
14552            first = false;
14553        }
14554        if remaining & Self::_2_PROTECTED_ACCESS_ONLY.0 != 0 {
14555            if !first {
14556                f.write_str(" | ")?;
14557            }
14558            f.write_str("_2_PROTECTED_ACCESS_ONLY")?;
14559            remaining &= !Self::_2_PROTECTED_ACCESS_ONLY.0;
14560            first = false;
14561        }
14562        if remaining & Self::_2_EXECUTION_GRAPH_BIT.0 != 0 {
14563            if !first {
14564                f.write_str(" | ")?;
14565            }
14566            f.write_str("_2_EXECUTION_GRAPH_BIT")?;
14567            remaining &= !Self::_2_EXECUTION_GRAPH_BIT.0;
14568            first = false;
14569        }
14570        if remaining & Self::_2_DESCRIPTOR_HEAP.0 != 0 {
14571            if !first {
14572                f.write_str(" | ")?;
14573            }
14574            f.write_str("_2_DESCRIPTOR_HEAP")?;
14575            remaining &= !Self::_2_DESCRIPTOR_HEAP.0;
14576            first = false;
14577        }
14578        if remaining & Self::_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES.0 != 0
14579        {
14580            if !first {
14581                f.write_str(" | ")?;
14582            }
14583            f.write_str("_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES")?;
14584            remaining &= !Self::_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES.0;
14585            first = false;
14586        }
14587        if remaining & Self::_2_ENABLE_LEGACY_DITHERING.0 != 0 {
14588            if !first {
14589                f.write_str(" | ")?;
14590            }
14591            f.write_str("_2_ENABLE_LEGACY_DITHERING")?;
14592            remaining &= !Self::_2_ENABLE_LEGACY_DITHERING.0;
14593            first = false;
14594        }
14595        if remaining & Self::_2_DEFER_COMPILE.0 != 0 {
14596            if !first {
14597                f.write_str(" | ")?;
14598            }
14599            f.write_str("_2_DEFER_COMPILE")?;
14600            remaining &= !Self::_2_DEFER_COMPILE.0;
14601            first = false;
14602        }
14603        if remaining & Self::_2_CAPTURE_STATISTICS.0 != 0 {
14604            if !first {
14605                f.write_str(" | ")?;
14606            }
14607            f.write_str("_2_CAPTURE_STATISTICS")?;
14608            remaining &= !Self::_2_CAPTURE_STATISTICS.0;
14609            first = false;
14610        }
14611        if remaining & Self::_2_CAPTURE_INTERNAL_REPRESENTATIONS.0 != 0 {
14612            if !first {
14613                f.write_str(" | ")?;
14614            }
14615            f.write_str("_2_CAPTURE_INTERNAL_REPRESENTATIONS")?;
14616            remaining &= !Self::_2_CAPTURE_INTERNAL_REPRESENTATIONS.0;
14617            first = false;
14618        }
14619        if remaining & Self::_2_LINK_TIME_OPTIMIZATION.0 != 0 {
14620            if !first {
14621                f.write_str(" | ")?;
14622            }
14623            f.write_str("_2_LINK_TIME_OPTIMIZATION")?;
14624            remaining &= !Self::_2_LINK_TIME_OPTIMIZATION.0;
14625            first = false;
14626        }
14627        if remaining & Self::_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO.0 != 0 {
14628            if !first {
14629                f.write_str(" | ")?;
14630            }
14631            f.write_str("_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO")?;
14632            remaining &= !Self::_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO.0;
14633            first = false;
14634        }
14635        if remaining & Self::_2_LIBRARY.0 != 0 {
14636            if !first {
14637                f.write_str(" | ")?;
14638            }
14639            f.write_str("_2_LIBRARY")?;
14640            remaining &= !Self::_2_LIBRARY.0;
14641            first = false;
14642        }
14643        if remaining & Self::_2_RAY_TRACING_SKIP_TRIANGLES.0 != 0 {
14644            if !first {
14645                f.write_str(" | ")?;
14646            }
14647            f.write_str("_2_RAY_TRACING_SKIP_TRIANGLES")?;
14648            remaining &= !Self::_2_RAY_TRACING_SKIP_TRIANGLES.0;
14649            first = false;
14650        }
14651        if remaining & Self::_2_RAY_TRACING_SKIP_AABBS.0 != 0 {
14652            if !first {
14653                f.write_str(" | ")?;
14654            }
14655            f.write_str("_2_RAY_TRACING_SKIP_AABBS")?;
14656            remaining &= !Self::_2_RAY_TRACING_SKIP_AABBS.0;
14657            first = false;
14658        }
14659        if remaining & Self::_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0 != 0 {
14660            if !first {
14661                f.write_str(" | ")?;
14662            }
14663            f.write_str("_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS")?;
14664            remaining &= !Self::_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0;
14665            first = false;
14666        }
14667        if remaining & Self::_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0 != 0 {
14668            if !first {
14669                f.write_str(" | ")?;
14670            }
14671            f.write_str("_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS")?;
14672            remaining &= !Self::_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0;
14673            first = false;
14674        }
14675        if remaining & Self::_2_RAY_TRACING_NO_NULL_MISS_SHADERS.0 != 0 {
14676            if !first {
14677                f.write_str(" | ")?;
14678            }
14679            f.write_str("_2_RAY_TRACING_NO_NULL_MISS_SHADERS")?;
14680            remaining &= !Self::_2_RAY_TRACING_NO_NULL_MISS_SHADERS.0;
14681            first = false;
14682        }
14683        if remaining & Self::_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0 != 0 {
14684            if !first {
14685                f.write_str(" | ")?;
14686            }
14687            f.write_str("_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS")?;
14688            remaining &= !Self::_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0;
14689            first = false;
14690        }
14691        if remaining & Self::_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0 != 0 {
14692            if !first {
14693                f.write_str(" | ")?;
14694            }
14695            f.write_str("_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY")?;
14696            remaining &= !Self::_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0;
14697            first = false;
14698        }
14699        if remaining & Self::_2_INDIRECT_BINDABLE.0 != 0 {
14700            if !first {
14701                f.write_str(" | ")?;
14702            }
14703            f.write_str("_2_INDIRECT_BINDABLE")?;
14704            remaining &= !Self::_2_INDIRECT_BINDABLE.0;
14705            first = false;
14706        }
14707        if remaining & Self::_2_RAY_TRACING_ALLOW_MOTION.0 != 0 {
14708            if !first {
14709                f.write_str(" | ")?;
14710            }
14711            f.write_str("_2_RAY_TRACING_ALLOW_MOTION")?;
14712            remaining &= !Self::_2_RAY_TRACING_ALLOW_MOTION.0;
14713            first = false;
14714        }
14715        if remaining & Self::_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
14716            if !first {
14717                f.write_str(" | ")?;
14718            }
14719            f.write_str("_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT")?;
14720            remaining &= !Self::_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0;
14721            first = false;
14722        }
14723        if remaining & Self::_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0 != 0 {
14724            if !first {
14725                f.write_str(" | ")?;
14726            }
14727            f.write_str("_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT")?;
14728            remaining &= !Self::_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0;
14729            first = false;
14730        }
14731        if remaining & Self::_2_RAY_TRACING_OPACITY_MICROMAP.0 != 0 {
14732            if !first {
14733                f.write_str(" | ")?;
14734            }
14735            f.write_str("_2_RAY_TRACING_OPACITY_MICROMAP")?;
14736            remaining &= !Self::_2_RAY_TRACING_OPACITY_MICROMAP.0;
14737            first = false;
14738        }
14739        if remaining & Self::_2_COLOR_ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
14740            if !first {
14741                f.write_str(" | ")?;
14742            }
14743            f.write_str("_2_COLOR_ATTACHMENT_FEEDBACK_LOOP")?;
14744            remaining &= !Self::_2_COLOR_ATTACHMENT_FEEDBACK_LOOP.0;
14745            first = false;
14746        }
14747        if remaining & Self::_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0 != 0 {
14748            if !first {
14749                f.write_str(" | ")?;
14750            }
14751            f.write_str("_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP")?;
14752            remaining &= !Self::_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0;
14753            first = false;
14754        }
14755        if remaining & Self::_2_RAY_TRACING_DISPLACEMENT_MICROMAP.0 != 0 {
14756            if !first {
14757                f.write_str(" | ")?;
14758            }
14759            f.write_str("_2_RAY_TRACING_DISPLACEMENT_MICROMAP")?;
14760            remaining &= !Self::_2_RAY_TRACING_DISPLACEMENT_MICROMAP.0;
14761            first = false;
14762        }
14763        if remaining & Self::_2_DESCRIPTOR_BUFFER.0 != 0 {
14764            if !first {
14765                f.write_str(" | ")?;
14766            }
14767            f.write_str("_2_DESCRIPTOR_BUFFER")?;
14768            remaining &= !Self::_2_DESCRIPTOR_BUFFER.0;
14769            first = false;
14770        }
14771        if remaining & Self::_2_DISALLOW_OPACITY_MICROMAP_BIT.0 != 0 {
14772            if !first {
14773                f.write_str(" | ")?;
14774            }
14775            f.write_str("_2_DISALLOW_OPACITY_MICROMAP_BIT")?;
14776            remaining &= !Self::_2_DISALLOW_OPACITY_MICROMAP_BIT.0;
14777            first = false;
14778        }
14779        if remaining & Self::_2_INSTRUMENT_SHADERS_BIT.0 != 0 {
14780            if !first {
14781                f.write_str(" | ")?;
14782            }
14783            f.write_str("_2_INSTRUMENT_SHADERS_BIT")?;
14784            remaining &= !Self::_2_INSTRUMENT_SHADERS_BIT.0;
14785            first = false;
14786        }
14787        if remaining & Self::_2_CAPTURE_DATA.0 != 0 {
14788            if !first {
14789                f.write_str(" | ")?;
14790            }
14791            f.write_str("_2_CAPTURE_DATA")?;
14792            remaining &= !Self::_2_CAPTURE_DATA.0;
14793            first = false;
14794        }
14795        if remaining & Self::_2_PER_LAYER_FRAGMENT_DENSITY_BIT.0 != 0 {
14796            if !first {
14797                f.write_str(" | ")?;
14798            }
14799            f.write_str("_2_PER_LAYER_FRAGMENT_DENSITY_BIT")?;
14800            remaining &= !Self::_2_PER_LAYER_FRAGMENT_DENSITY_BIT.0;
14801            first = false;
14802        }
14803        if remaining & Self::_2_64_BIT_INDEXING.0 != 0 {
14804            if !first {
14805                f.write_str(" | ")?;
14806            }
14807            f.write_str("_2_64_BIT_INDEXING")?;
14808            remaining &= !Self::_2_64_BIT_INDEXING.0;
14809            first = false;
14810        }
14811        if remaining != 0u64 {
14812            if !first {
14813                f.write_str(" | ")?;
14814            }
14815            write!(f, "{:#x}", remaining)?;
14816        } else if first {
14817            f.write_str("(empty)")?;
14818        }
14819        Ok(())
14820    }
14821}
14822///[`VkPipelineCreationFeedbackFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackFlagBits.html)
14823#[repr(transparent)]
14824#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
14825#[doc(alias = "VkPipelineCreationFeedbackFlagBits")]
14826pub struct PipelineCreationFeedbackFlagBits(u32);
14827impl PipelineCreationFeedbackFlagBits {
14828    #[inline]
14829    pub const fn empty() -> Self {
14830        Self(0u32)
14831    }
14832    #[inline]
14833    pub const fn from_raw(value: u32) -> Self {
14834        Self(value)
14835    }
14836    #[inline]
14837    pub const fn as_raw(self) -> u32 {
14838        self.0
14839    }
14840    #[inline]
14841    pub const fn is_empty(self) -> bool {
14842        self.0 == 0u32
14843    }
14844    #[inline]
14845    pub const fn contains(self, other: Self) -> bool {
14846        (self.0 & other.0) == other.0
14847    }
14848    ///Bit 0.
14849    pub const VALID: Self = Self(1u32);
14850    ///Bit 1.
14851    pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(2u32);
14852    ///Bit 2.
14853    pub const BASE_PIPELINE_ACCELERATION: Self = Self(4u32);
14854}
14855impl core::ops::BitOr for PipelineCreationFeedbackFlagBits {
14856    type Output = Self;
14857    #[inline]
14858    fn bitor(self, rhs: Self) -> Self {
14859        Self(self.0 | rhs.0)
14860    }
14861}
14862impl core::ops::BitOrAssign for PipelineCreationFeedbackFlagBits {
14863    #[inline]
14864    fn bitor_assign(&mut self, rhs: Self) {
14865        self.0 |= rhs.0;
14866    }
14867}
14868impl core::ops::BitAnd for PipelineCreationFeedbackFlagBits {
14869    type Output = Self;
14870    #[inline]
14871    fn bitand(self, rhs: Self) -> Self {
14872        Self(self.0 & rhs.0)
14873    }
14874}
14875impl core::ops::BitAndAssign for PipelineCreationFeedbackFlagBits {
14876    #[inline]
14877    fn bitand_assign(&mut self, rhs: Self) {
14878        self.0 &= rhs.0;
14879    }
14880}
14881impl core::ops::BitXor for PipelineCreationFeedbackFlagBits {
14882    type Output = Self;
14883    #[inline]
14884    fn bitxor(self, rhs: Self) -> Self {
14885        Self(self.0 ^ rhs.0)
14886    }
14887}
14888impl core::ops::BitXorAssign for PipelineCreationFeedbackFlagBits {
14889    #[inline]
14890    fn bitxor_assign(&mut self, rhs: Self) {
14891        self.0 ^= rhs.0;
14892    }
14893}
14894impl core::ops::Not for PipelineCreationFeedbackFlagBits {
14895    type Output = Self;
14896    #[inline]
14897    fn not(self) -> Self {
14898        Self(!self.0)
14899    }
14900}
14901impl core::fmt::Debug for PipelineCreationFeedbackFlagBits {
14902    #[allow(unused_mut, unused_variables)]
14903    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
14904        let mut first = true;
14905        let mut remaining = self.0;
14906        if remaining & Self::VALID.0 != 0 {
14907            if !first {
14908                f.write_str(" | ")?;
14909            }
14910            f.write_str("VALID")?;
14911            remaining &= !Self::VALID.0;
14912            first = false;
14913        }
14914        if remaining & Self::APPLICATION_PIPELINE_CACHE_HIT.0 != 0 {
14915            if !first {
14916                f.write_str(" | ")?;
14917            }
14918            f.write_str("APPLICATION_PIPELINE_CACHE_HIT")?;
14919            remaining &= !Self::APPLICATION_PIPELINE_CACHE_HIT.0;
14920            first = false;
14921        }
14922        if remaining & Self::BASE_PIPELINE_ACCELERATION.0 != 0 {
14923            if !first {
14924                f.write_str(" | ")?;
14925            }
14926            f.write_str("BASE_PIPELINE_ACCELERATION")?;
14927            remaining &= !Self::BASE_PIPELINE_ACCELERATION.0;
14928            first = false;
14929        }
14930        if remaining != 0u32 {
14931            if !first {
14932                f.write_str(" | ")?;
14933            }
14934            write!(f, "{:#x}", remaining)?;
14935        } else if first {
14936            f.write_str("(empty)")?;
14937        }
14938        Ok(())
14939    }
14940}
14941///[`VkPipelineDepthStencilStateCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateFlagBits.html)
14942#[repr(transparent)]
14943#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
14944#[doc(alias = "VkPipelineDepthStencilStateCreateFlagBits")]
14945pub struct PipelineDepthStencilStateCreateFlagBits(u32);
14946impl PipelineDepthStencilStateCreateFlagBits {
14947    #[inline]
14948    pub const fn empty() -> Self {
14949        Self(0u32)
14950    }
14951    #[inline]
14952    pub const fn from_raw(value: u32) -> Self {
14953        Self(value)
14954    }
14955    #[inline]
14956    pub const fn as_raw(self) -> u32 {
14957        self.0
14958    }
14959    #[inline]
14960    pub const fn is_empty(self) -> bool {
14961        self.0 == 0u32
14962    }
14963    #[inline]
14964    pub const fn contains(self, other: Self) -> bool {
14965        (self.0 & other.0) == other.0
14966    }
14967    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS;
14968    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS;
14969    ///Bit 0.
14970    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS: Self = Self(1u32);
14971    ///Bit 1.
14972    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS: Self = Self(2u32);
14973}
14974impl core::ops::BitOr for PipelineDepthStencilStateCreateFlagBits {
14975    type Output = Self;
14976    #[inline]
14977    fn bitor(self, rhs: Self) -> Self {
14978        Self(self.0 | rhs.0)
14979    }
14980}
14981impl core::ops::BitOrAssign for PipelineDepthStencilStateCreateFlagBits {
14982    #[inline]
14983    fn bitor_assign(&mut self, rhs: Self) {
14984        self.0 |= rhs.0;
14985    }
14986}
14987impl core::ops::BitAnd for PipelineDepthStencilStateCreateFlagBits {
14988    type Output = Self;
14989    #[inline]
14990    fn bitand(self, rhs: Self) -> Self {
14991        Self(self.0 & rhs.0)
14992    }
14993}
14994impl core::ops::BitAndAssign for PipelineDepthStencilStateCreateFlagBits {
14995    #[inline]
14996    fn bitand_assign(&mut self, rhs: Self) {
14997        self.0 &= rhs.0;
14998    }
14999}
15000impl core::ops::BitXor for PipelineDepthStencilStateCreateFlagBits {
15001    type Output = Self;
15002    #[inline]
15003    fn bitxor(self, rhs: Self) -> Self {
15004        Self(self.0 ^ rhs.0)
15005    }
15006}
15007impl core::ops::BitXorAssign for PipelineDepthStencilStateCreateFlagBits {
15008    #[inline]
15009    fn bitxor_assign(&mut self, rhs: Self) {
15010        self.0 ^= rhs.0;
15011    }
15012}
15013impl core::ops::Not for PipelineDepthStencilStateCreateFlagBits {
15014    type Output = Self;
15015    #[inline]
15016    fn not(self) -> Self {
15017        Self(!self.0)
15018    }
15019}
15020impl core::fmt::Debug for PipelineDepthStencilStateCreateFlagBits {
15021    #[allow(unused_mut, unused_variables)]
15022    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15023        let mut first = true;
15024        let mut remaining = self.0;
15025        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS.0 != 0 {
15026            if !first {
15027                f.write_str(" | ")?;
15028            }
15029            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS")?;
15030            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS.0;
15031            first = false;
15032        }
15033        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS.0 != 0 {
15034            if !first {
15035                f.write_str(" | ")?;
15036            }
15037            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS")?;
15038            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS.0;
15039            first = false;
15040        }
15041        if remaining != 0u32 {
15042            if !first {
15043                f.write_str(" | ")?;
15044            }
15045            write!(f, "{:#x}", remaining)?;
15046        } else if first {
15047            f.write_str("(empty)")?;
15048        }
15049        Ok(())
15050    }
15051}
15052///[`VkPipelineLayoutCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlagBits.html)
15053#[repr(transparent)]
15054#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
15055#[doc(alias = "VkPipelineLayoutCreateFlagBits")]
15056pub struct PipelineLayoutCreateFlagBits(u32);
15057impl PipelineLayoutCreateFlagBits {
15058    #[inline]
15059    pub const fn empty() -> Self {
15060        Self(0u32)
15061    }
15062    #[inline]
15063    pub const fn from_raw(value: u32) -> Self {
15064        Self(value)
15065    }
15066    #[inline]
15067    pub const fn as_raw(self) -> u32 {
15068        self.0
15069    }
15070    #[inline]
15071    pub const fn is_empty(self) -> bool {
15072        self.0 == 0u32
15073    }
15074    #[inline]
15075    pub const fn contains(self, other: Self) -> bool {
15076        (self.0 & other.0) == other.0
15077    }
15078    ///Bit 1.
15079    pub const INDEPENDENT_SETS: Self = Self(2u32);
15080}
15081impl core::ops::BitOr for PipelineLayoutCreateFlagBits {
15082    type Output = Self;
15083    #[inline]
15084    fn bitor(self, rhs: Self) -> Self {
15085        Self(self.0 | rhs.0)
15086    }
15087}
15088impl core::ops::BitOrAssign for PipelineLayoutCreateFlagBits {
15089    #[inline]
15090    fn bitor_assign(&mut self, rhs: Self) {
15091        self.0 |= rhs.0;
15092    }
15093}
15094impl core::ops::BitAnd for PipelineLayoutCreateFlagBits {
15095    type Output = Self;
15096    #[inline]
15097    fn bitand(self, rhs: Self) -> Self {
15098        Self(self.0 & rhs.0)
15099    }
15100}
15101impl core::ops::BitAndAssign for PipelineLayoutCreateFlagBits {
15102    #[inline]
15103    fn bitand_assign(&mut self, rhs: Self) {
15104        self.0 &= rhs.0;
15105    }
15106}
15107impl core::ops::BitXor for PipelineLayoutCreateFlagBits {
15108    type Output = Self;
15109    #[inline]
15110    fn bitxor(self, rhs: Self) -> Self {
15111        Self(self.0 ^ rhs.0)
15112    }
15113}
15114impl core::ops::BitXorAssign for PipelineLayoutCreateFlagBits {
15115    #[inline]
15116    fn bitxor_assign(&mut self, rhs: Self) {
15117        self.0 ^= rhs.0;
15118    }
15119}
15120impl core::ops::Not for PipelineLayoutCreateFlagBits {
15121    type Output = Self;
15122    #[inline]
15123    fn not(self) -> Self {
15124        Self(!self.0)
15125    }
15126}
15127impl core::fmt::Debug for PipelineLayoutCreateFlagBits {
15128    #[allow(unused_mut, unused_variables)]
15129    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15130        let mut first = true;
15131        let mut remaining = self.0;
15132        if remaining & Self::INDEPENDENT_SETS.0 != 0 {
15133            if !first {
15134                f.write_str(" | ")?;
15135            }
15136            f.write_str("INDEPENDENT_SETS")?;
15137            remaining &= !Self::INDEPENDENT_SETS.0;
15138            first = false;
15139        }
15140        if remaining != 0u32 {
15141            if !first {
15142                f.write_str(" | ")?;
15143            }
15144            write!(f, "{:#x}", remaining)?;
15145        } else if first {
15146            f.write_str("(empty)")?;
15147        }
15148        Ok(())
15149    }
15150}
15151///[`VkPipelineShaderStageCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateFlagBits.html)
15152#[repr(transparent)]
15153#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
15154#[doc(alias = "VkPipelineShaderStageCreateFlagBits")]
15155pub struct PipelineShaderStageCreateFlagBits(u32);
15156impl PipelineShaderStageCreateFlagBits {
15157    #[inline]
15158    pub const fn empty() -> Self {
15159        Self(0u32)
15160    }
15161    #[inline]
15162    pub const fn from_raw(value: u32) -> Self {
15163        Self(value)
15164    }
15165    #[inline]
15166    pub const fn as_raw(self) -> u32 {
15167        self.0
15168    }
15169    #[inline]
15170    pub const fn is_empty(self) -> bool {
15171        self.0 == 0u32
15172    }
15173    #[inline]
15174    pub const fn contains(self, other: Self) -> bool {
15175        (self.0 & other.0) == other.0
15176    }
15177    ///Bit 0.
15178    pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(1u32);
15179    ///Bit 1.
15180    pub const REQUIRE_FULL_SUBGROUPS: Self = Self(2u32);
15181}
15182impl core::ops::BitOr for PipelineShaderStageCreateFlagBits {
15183    type Output = Self;
15184    #[inline]
15185    fn bitor(self, rhs: Self) -> Self {
15186        Self(self.0 | rhs.0)
15187    }
15188}
15189impl core::ops::BitOrAssign for PipelineShaderStageCreateFlagBits {
15190    #[inline]
15191    fn bitor_assign(&mut self, rhs: Self) {
15192        self.0 |= rhs.0;
15193    }
15194}
15195impl core::ops::BitAnd for PipelineShaderStageCreateFlagBits {
15196    type Output = Self;
15197    #[inline]
15198    fn bitand(self, rhs: Self) -> Self {
15199        Self(self.0 & rhs.0)
15200    }
15201}
15202impl core::ops::BitAndAssign for PipelineShaderStageCreateFlagBits {
15203    #[inline]
15204    fn bitand_assign(&mut self, rhs: Self) {
15205        self.0 &= rhs.0;
15206    }
15207}
15208impl core::ops::BitXor for PipelineShaderStageCreateFlagBits {
15209    type Output = Self;
15210    #[inline]
15211    fn bitxor(self, rhs: Self) -> Self {
15212        Self(self.0 ^ rhs.0)
15213    }
15214}
15215impl core::ops::BitXorAssign for PipelineShaderStageCreateFlagBits {
15216    #[inline]
15217    fn bitxor_assign(&mut self, rhs: Self) {
15218        self.0 ^= rhs.0;
15219    }
15220}
15221impl core::ops::Not for PipelineShaderStageCreateFlagBits {
15222    type Output = Self;
15223    #[inline]
15224    fn not(self) -> Self {
15225        Self(!self.0)
15226    }
15227}
15228impl core::fmt::Debug for PipelineShaderStageCreateFlagBits {
15229    #[allow(unused_mut, unused_variables)]
15230    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15231        let mut first = true;
15232        let mut remaining = self.0;
15233        if remaining & Self::ALLOW_VARYING_SUBGROUP_SIZE.0 != 0 {
15234            if !first {
15235                f.write_str(" | ")?;
15236            }
15237            f.write_str("ALLOW_VARYING_SUBGROUP_SIZE")?;
15238            remaining &= !Self::ALLOW_VARYING_SUBGROUP_SIZE.0;
15239            first = false;
15240        }
15241        if remaining & Self::REQUIRE_FULL_SUBGROUPS.0 != 0 {
15242            if !first {
15243                f.write_str(" | ")?;
15244            }
15245            f.write_str("REQUIRE_FULL_SUBGROUPS")?;
15246            remaining &= !Self::REQUIRE_FULL_SUBGROUPS.0;
15247            first = false;
15248        }
15249        if remaining != 0u32 {
15250            if !first {
15251                f.write_str(" | ")?;
15252            }
15253            write!(f, "{:#x}", remaining)?;
15254        } else if first {
15255            f.write_str("(empty)")?;
15256        }
15257        Ok(())
15258    }
15259}
15260///[`VkPipelineStageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits.html)
15261#[repr(transparent)]
15262#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
15263#[doc(alias = "VkPipelineStageFlagBits")]
15264pub struct PipelineStageFlagBits(u32);
15265impl PipelineStageFlagBits {
15266    #[inline]
15267    pub const fn empty() -> Self {
15268        Self(0u32)
15269    }
15270    #[inline]
15271    pub const fn from_raw(value: u32) -> Self {
15272        Self(value)
15273    }
15274    #[inline]
15275    pub const fn as_raw(self) -> u32 {
15276        self.0
15277    }
15278    #[inline]
15279    pub const fn is_empty(self) -> bool {
15280        self.0 == 0u32
15281    }
15282    #[inline]
15283    pub const fn contains(self, other: Self) -> bool {
15284        (self.0 & other.0) == other.0
15285    }
15286    ///Bit 0.
15287    pub const TOP_OF_PIPE: Self = Self(1u32);
15288    ///Bit 1.
15289    pub const DRAW_INDIRECT: Self = Self(2u32);
15290    ///Bit 2.
15291    pub const VERTEX_INPUT: Self = Self(4u32);
15292    ///Bit 3.
15293    pub const VERTEX_SHADER: Self = Self(8u32);
15294    ///Bit 4.
15295    pub const TESSELLATION_CONTROL_SHADER: Self = Self(16u32);
15296    ///Bit 5.
15297    pub const TESSELLATION_EVALUATION_SHADER: Self = Self(32u32);
15298    ///Bit 6.
15299    pub const GEOMETRY_SHADER: Self = Self(64u32);
15300    ///Bit 7.
15301    pub const FRAGMENT_SHADER: Self = Self(128u32);
15302    ///Bit 8.
15303    pub const EARLY_FRAGMENT_TESTS: Self = Self(256u32);
15304    ///Bit 9.
15305    pub const LATE_FRAGMENT_TESTS: Self = Self(512u32);
15306    ///Bit 10.
15307    pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(1024u32);
15308    ///Bit 11.
15309    pub const COMPUTE_SHADER: Self = Self(2048u32);
15310    ///Bit 12.
15311    pub const TRANSFER: Self = Self(4096u32);
15312    ///Bit 13.
15313    pub const BOTTOM_OF_PIPE: Self = Self(8192u32);
15314    ///Bit 14.
15315    pub const HOST: Self = Self(16384u32);
15316    ///Bit 15.
15317    pub const ALL_GRAPHICS: Self = Self(32768u32);
15318    ///Bit 16.
15319    pub const ALL_COMMANDS: Self = Self(65536u32);
15320    pub const NONE: Self = Self(0u32);
15321    ///Bit 24.
15322    pub const TRANSFORM_FEEDBACK: Self = Self(16777216u32);
15323    ///Bit 18.
15324    pub const CONDITIONAL_RENDERING: Self = Self(262144u32);
15325    ///Bit 25.
15326    pub const ACCELERATION_STRUCTURE_BUILD: Self = Self(33554432u32);
15327    ///Bit 21.
15328    pub const RAY_TRACING_SHADER: Self = Self(2097152u32);
15329    pub const SHADING_RATE_IMAGE: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT;
15330    ///Bit 23.
15331    pub const FRAGMENT_DENSITY_PROCESS: Self = Self(8388608u32);
15332    ///Bit 22.
15333    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(4194304u32);
15334}
15335impl core::ops::BitOr for PipelineStageFlagBits {
15336    type Output = Self;
15337    #[inline]
15338    fn bitor(self, rhs: Self) -> Self {
15339        Self(self.0 | rhs.0)
15340    }
15341}
15342impl core::ops::BitOrAssign for PipelineStageFlagBits {
15343    #[inline]
15344    fn bitor_assign(&mut self, rhs: Self) {
15345        self.0 |= rhs.0;
15346    }
15347}
15348impl core::ops::BitAnd for PipelineStageFlagBits {
15349    type Output = Self;
15350    #[inline]
15351    fn bitand(self, rhs: Self) -> Self {
15352        Self(self.0 & rhs.0)
15353    }
15354}
15355impl core::ops::BitAndAssign for PipelineStageFlagBits {
15356    #[inline]
15357    fn bitand_assign(&mut self, rhs: Self) {
15358        self.0 &= rhs.0;
15359    }
15360}
15361impl core::ops::BitXor for PipelineStageFlagBits {
15362    type Output = Self;
15363    #[inline]
15364    fn bitxor(self, rhs: Self) -> Self {
15365        Self(self.0 ^ rhs.0)
15366    }
15367}
15368impl core::ops::BitXorAssign for PipelineStageFlagBits {
15369    #[inline]
15370    fn bitxor_assign(&mut self, rhs: Self) {
15371        self.0 ^= rhs.0;
15372    }
15373}
15374impl core::ops::Not for PipelineStageFlagBits {
15375    type Output = Self;
15376    #[inline]
15377    fn not(self) -> Self {
15378        Self(!self.0)
15379    }
15380}
15381impl core::fmt::Debug for PipelineStageFlagBits {
15382    #[allow(unused_mut, unused_variables)]
15383    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15384        let mut first = true;
15385        let mut remaining = self.0;
15386        if remaining & Self::TOP_OF_PIPE.0 != 0 {
15387            if !first {
15388                f.write_str(" | ")?;
15389            }
15390            f.write_str("TOP_OF_PIPE")?;
15391            remaining &= !Self::TOP_OF_PIPE.0;
15392            first = false;
15393        }
15394        if remaining & Self::DRAW_INDIRECT.0 != 0 {
15395            if !first {
15396                f.write_str(" | ")?;
15397            }
15398            f.write_str("DRAW_INDIRECT")?;
15399            remaining &= !Self::DRAW_INDIRECT.0;
15400            first = false;
15401        }
15402        if remaining & Self::VERTEX_INPUT.0 != 0 {
15403            if !first {
15404                f.write_str(" | ")?;
15405            }
15406            f.write_str("VERTEX_INPUT")?;
15407            remaining &= !Self::VERTEX_INPUT.0;
15408            first = false;
15409        }
15410        if remaining & Self::VERTEX_SHADER.0 != 0 {
15411            if !first {
15412                f.write_str(" | ")?;
15413            }
15414            f.write_str("VERTEX_SHADER")?;
15415            remaining &= !Self::VERTEX_SHADER.0;
15416            first = false;
15417        }
15418        if remaining & Self::TESSELLATION_CONTROL_SHADER.0 != 0 {
15419            if !first {
15420                f.write_str(" | ")?;
15421            }
15422            f.write_str("TESSELLATION_CONTROL_SHADER")?;
15423            remaining &= !Self::TESSELLATION_CONTROL_SHADER.0;
15424            first = false;
15425        }
15426        if remaining & Self::TESSELLATION_EVALUATION_SHADER.0 != 0 {
15427            if !first {
15428                f.write_str(" | ")?;
15429            }
15430            f.write_str("TESSELLATION_EVALUATION_SHADER")?;
15431            remaining &= !Self::TESSELLATION_EVALUATION_SHADER.0;
15432            first = false;
15433        }
15434        if remaining & Self::GEOMETRY_SHADER.0 != 0 {
15435            if !first {
15436                f.write_str(" | ")?;
15437            }
15438            f.write_str("GEOMETRY_SHADER")?;
15439            remaining &= !Self::GEOMETRY_SHADER.0;
15440            first = false;
15441        }
15442        if remaining & Self::FRAGMENT_SHADER.0 != 0 {
15443            if !first {
15444                f.write_str(" | ")?;
15445            }
15446            f.write_str("FRAGMENT_SHADER")?;
15447            remaining &= !Self::FRAGMENT_SHADER.0;
15448            first = false;
15449        }
15450        if remaining & Self::EARLY_FRAGMENT_TESTS.0 != 0 {
15451            if !first {
15452                f.write_str(" | ")?;
15453            }
15454            f.write_str("EARLY_FRAGMENT_TESTS")?;
15455            remaining &= !Self::EARLY_FRAGMENT_TESTS.0;
15456            first = false;
15457        }
15458        if remaining & Self::LATE_FRAGMENT_TESTS.0 != 0 {
15459            if !first {
15460                f.write_str(" | ")?;
15461            }
15462            f.write_str("LATE_FRAGMENT_TESTS")?;
15463            remaining &= !Self::LATE_FRAGMENT_TESTS.0;
15464            first = false;
15465        }
15466        if remaining & Self::COLOR_ATTACHMENT_OUTPUT.0 != 0 {
15467            if !first {
15468                f.write_str(" | ")?;
15469            }
15470            f.write_str("COLOR_ATTACHMENT_OUTPUT")?;
15471            remaining &= !Self::COLOR_ATTACHMENT_OUTPUT.0;
15472            first = false;
15473        }
15474        if remaining & Self::COMPUTE_SHADER.0 != 0 {
15475            if !first {
15476                f.write_str(" | ")?;
15477            }
15478            f.write_str("COMPUTE_SHADER")?;
15479            remaining &= !Self::COMPUTE_SHADER.0;
15480            first = false;
15481        }
15482        if remaining & Self::TRANSFER.0 != 0 {
15483            if !first {
15484                f.write_str(" | ")?;
15485            }
15486            f.write_str("TRANSFER")?;
15487            remaining &= !Self::TRANSFER.0;
15488            first = false;
15489        }
15490        if remaining & Self::BOTTOM_OF_PIPE.0 != 0 {
15491            if !first {
15492                f.write_str(" | ")?;
15493            }
15494            f.write_str("BOTTOM_OF_PIPE")?;
15495            remaining &= !Self::BOTTOM_OF_PIPE.0;
15496            first = false;
15497        }
15498        if remaining & Self::HOST.0 != 0 {
15499            if !first {
15500                f.write_str(" | ")?;
15501            }
15502            f.write_str("HOST")?;
15503            remaining &= !Self::HOST.0;
15504            first = false;
15505        }
15506        if remaining & Self::ALL_GRAPHICS.0 != 0 {
15507            if !first {
15508                f.write_str(" | ")?;
15509            }
15510            f.write_str("ALL_GRAPHICS")?;
15511            remaining &= !Self::ALL_GRAPHICS.0;
15512            first = false;
15513        }
15514        if remaining & Self::ALL_COMMANDS.0 != 0 {
15515            if !first {
15516                f.write_str(" | ")?;
15517            }
15518            f.write_str("ALL_COMMANDS")?;
15519            remaining &= !Self::ALL_COMMANDS.0;
15520            first = false;
15521        }
15522        if remaining & Self::TRANSFORM_FEEDBACK.0 != 0 {
15523            if !first {
15524                f.write_str(" | ")?;
15525            }
15526            f.write_str("TRANSFORM_FEEDBACK")?;
15527            remaining &= !Self::TRANSFORM_FEEDBACK.0;
15528            first = false;
15529        }
15530        if remaining & Self::CONDITIONAL_RENDERING.0 != 0 {
15531            if !first {
15532                f.write_str(" | ")?;
15533            }
15534            f.write_str("CONDITIONAL_RENDERING")?;
15535            remaining &= !Self::CONDITIONAL_RENDERING.0;
15536            first = false;
15537        }
15538        if remaining & Self::ACCELERATION_STRUCTURE_BUILD.0 != 0 {
15539            if !first {
15540                f.write_str(" | ")?;
15541            }
15542            f.write_str("ACCELERATION_STRUCTURE_BUILD")?;
15543            remaining &= !Self::ACCELERATION_STRUCTURE_BUILD.0;
15544            first = false;
15545        }
15546        if remaining & Self::RAY_TRACING_SHADER.0 != 0 {
15547            if !first {
15548                f.write_str(" | ")?;
15549            }
15550            f.write_str("RAY_TRACING_SHADER")?;
15551            remaining &= !Self::RAY_TRACING_SHADER.0;
15552            first = false;
15553        }
15554        if remaining & Self::FRAGMENT_DENSITY_PROCESS.0 != 0 {
15555            if !first {
15556                f.write_str(" | ")?;
15557            }
15558            f.write_str("FRAGMENT_DENSITY_PROCESS")?;
15559            remaining &= !Self::FRAGMENT_DENSITY_PROCESS.0;
15560            first = false;
15561        }
15562        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
15563            if !first {
15564                f.write_str(" | ")?;
15565            }
15566            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT")?;
15567            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0;
15568            first = false;
15569        }
15570        if remaining != 0u32 {
15571            if !first {
15572                f.write_str(" | ")?;
15573            }
15574            write!(f, "{:#x}", remaining)?;
15575        } else if first {
15576            f.write_str("(empty)")?;
15577        }
15578        Ok(())
15579    }
15580}
15581///[`VkPipelineStageFlagBits2`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits2.html)
15582#[repr(transparent)]
15583#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
15584#[doc(alias = "VkPipelineStageFlagBits2")]
15585pub struct PipelineStageFlagBits2(u64);
15586impl PipelineStageFlagBits2 {
15587    #[inline]
15588    pub const fn empty() -> Self {
15589        Self(0u64)
15590    }
15591    #[inline]
15592    pub const fn from_raw(value: u64) -> Self {
15593        Self(value)
15594    }
15595    #[inline]
15596    pub const fn as_raw(self) -> u64 {
15597        self.0
15598    }
15599    #[inline]
15600    pub const fn is_empty(self) -> bool {
15601        self.0 == 0u64
15602    }
15603    #[inline]
15604    pub const fn contains(self, other: Self) -> bool {
15605        (self.0 & other.0) == other.0
15606    }
15607    pub const _2_NONE: Self = Self(0u64);
15608    ///Bit 0.
15609    pub const _2_TOP_OF_PIPE: Self = Self(1u64);
15610    ///Bit 1.
15611    pub const _2_DRAW_INDIRECT: Self = Self(2u64);
15612    ///Bit 2.
15613    pub const _2_VERTEX_INPUT: Self = Self(4u64);
15614    ///Bit 3.
15615    pub const _2_VERTEX_SHADER: Self = Self(8u64);
15616    ///Bit 4.
15617    pub const _2_TESSELLATION_CONTROL_SHADER: Self = Self(16u64);
15618    ///Bit 5.
15619    pub const _2_TESSELLATION_EVALUATION_SHADER: Self = Self(32u64);
15620    ///Bit 6.
15621    pub const _2_GEOMETRY_SHADER: Self = Self(64u64);
15622    ///Bit 7.
15623    pub const _2_FRAGMENT_SHADER: Self = Self(128u64);
15624    ///Bit 8.
15625    pub const _2_EARLY_FRAGMENT_TESTS: Self = Self(256u64);
15626    ///Bit 9.
15627    pub const _2_LATE_FRAGMENT_TESTS: Self = Self(512u64);
15628    ///Bit 10.
15629    pub const _2_COLOR_ATTACHMENT_OUTPUT: Self = Self(1024u64);
15630    ///Bit 11.
15631    pub const _2_COMPUTE_SHADER: Self = Self(2048u64);
15632    ///Bit 12.
15633    pub const _2_ALL_TRANSFER: Self = Self(4096u64);
15634    pub const _2_TRANSFER: Self = Self::_2_ALL_TRANSFER;
15635    ///Bit 13.
15636    pub const _2_BOTTOM_OF_PIPE: Self = Self(8192u64);
15637    ///Bit 14.
15638    pub const _2_HOST: Self = Self(16384u64);
15639    ///Bit 15.
15640    pub const _2_ALL_GRAPHICS: Self = Self(32768u64);
15641    ///Bit 16.
15642    pub const _2_ALL_COMMANDS: Self = Self(65536u64);
15643    ///Bit 32.
15644    pub const _2_COPY: Self = Self(4294967296u64);
15645    ///Bit 33.
15646    pub const _2_RESOLVE: Self = Self(8589934592u64);
15647    ///Bit 34.
15648    pub const _2_BLIT: Self = Self(17179869184u64);
15649    ///Bit 35.
15650    pub const _2_CLEAR: Self = Self(34359738368u64);
15651    ///Bit 36.
15652    pub const _2_INDEX_INPUT: Self = Self(68719476736u64);
15653    ///Bit 37.
15654    pub const _2_VERTEX_ATTRIBUTE_INPUT: Self = Self(137438953472u64);
15655    ///Bit 38.
15656    pub const _2_PRE_RASTERIZATION_SHADERS: Self = Self(274877906944u64);
15657    ///Bit 26.
15658    pub const _2_VIDEO_DECODE: Self = Self(67108864u64);
15659    ///Bit 27.
15660    pub const _2_VIDEO_ENCODE: Self = Self(134217728u64);
15661    ///Bit 24.
15662    pub const _2_TRANSFORM_FEEDBACK: Self = Self(16777216u64);
15663    ///Bit 18.
15664    pub const _2_CONDITIONAL_RENDERING: Self = Self(262144u64);
15665    ///Bit 22.
15666    pub const _2_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(4194304u64);
15667    pub const _2_SHADING_RATE_IMAGE: Self = Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT;
15668    ///Bit 25.
15669    pub const _2_ACCELERATION_STRUCTURE_BUILD: Self = Self(33554432u64);
15670    ///Bit 21.
15671    pub const _2_RAY_TRACING_SHADER: Self = Self(2097152u64);
15672    ///Bit 23.
15673    pub const _2_FRAGMENT_DENSITY_PROCESS: Self = Self(8388608u64);
15674    ///Bit 39.
15675    pub const _2_SUBPASS_SHADER_BIT: Self = Self(549755813888u64);
15676    pub const _2_SUBPASS_SHADING_BIT: Self = Self::_2_SUBPASS_SHADER_BIT;
15677    ///Bit 40.
15678    pub const _2_INVOCATION_MASK_BIT: Self = Self(1099511627776u64);
15679    ///Bit 28.
15680    pub const _2_ACCELERATION_STRUCTURE_COPY: Self = Self(268435456u64);
15681    ///Bit 30.
15682    pub const _2_MICROMAP_BUILD: Self = Self(1073741824u64);
15683    ///Bit 41.
15684    pub const _2_CLUSTER_CULLING_SHADER_BIT: Self = Self(2199023255552u64);
15685    ///Bit 29.
15686    pub const _2_OPTICAL_FLOW: Self = Self(536870912u64);
15687    ///Bit 44.
15688    pub const _2_CONVERT_COOPERATIVE_VECTOR_MATRIX: Self = Self(17592186044416u64);
15689    ///Bit 42.
15690    pub const _2_DATA_GRAPH_BIT: Self = Self(4398046511104u64);
15691    ///Bit 46.
15692    pub const _2_COPY_INDIRECT: Self = Self(70368744177664u64);
15693    ///Bit 45.
15694    pub const _2_MEMORY_DECOMPRESSION: Self = Self(35184372088832u64);
15695}
15696impl core::ops::BitOr for PipelineStageFlagBits2 {
15697    type Output = Self;
15698    #[inline]
15699    fn bitor(self, rhs: Self) -> Self {
15700        Self(self.0 | rhs.0)
15701    }
15702}
15703impl core::ops::BitOrAssign for PipelineStageFlagBits2 {
15704    #[inline]
15705    fn bitor_assign(&mut self, rhs: Self) {
15706        self.0 |= rhs.0;
15707    }
15708}
15709impl core::ops::BitAnd for PipelineStageFlagBits2 {
15710    type Output = Self;
15711    #[inline]
15712    fn bitand(self, rhs: Self) -> Self {
15713        Self(self.0 & rhs.0)
15714    }
15715}
15716impl core::ops::BitAndAssign for PipelineStageFlagBits2 {
15717    #[inline]
15718    fn bitand_assign(&mut self, rhs: Self) {
15719        self.0 &= rhs.0;
15720    }
15721}
15722impl core::ops::BitXor for PipelineStageFlagBits2 {
15723    type Output = Self;
15724    #[inline]
15725    fn bitxor(self, rhs: Self) -> Self {
15726        Self(self.0 ^ rhs.0)
15727    }
15728}
15729impl core::ops::BitXorAssign for PipelineStageFlagBits2 {
15730    #[inline]
15731    fn bitxor_assign(&mut self, rhs: Self) {
15732        self.0 ^= rhs.0;
15733    }
15734}
15735impl core::ops::Not for PipelineStageFlagBits2 {
15736    type Output = Self;
15737    #[inline]
15738    fn not(self) -> Self {
15739        Self(!self.0)
15740    }
15741}
15742impl core::fmt::Debug for PipelineStageFlagBits2 {
15743    #[allow(unused_mut, unused_variables)]
15744    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
15745        let mut first = true;
15746        let mut remaining = self.0;
15747        if remaining & Self::_2_TOP_OF_PIPE.0 != 0 {
15748            if !first {
15749                f.write_str(" | ")?;
15750            }
15751            f.write_str("_2_TOP_OF_PIPE")?;
15752            remaining &= !Self::_2_TOP_OF_PIPE.0;
15753            first = false;
15754        }
15755        if remaining & Self::_2_DRAW_INDIRECT.0 != 0 {
15756            if !first {
15757                f.write_str(" | ")?;
15758            }
15759            f.write_str("_2_DRAW_INDIRECT")?;
15760            remaining &= !Self::_2_DRAW_INDIRECT.0;
15761            first = false;
15762        }
15763        if remaining & Self::_2_VERTEX_INPUT.0 != 0 {
15764            if !first {
15765                f.write_str(" | ")?;
15766            }
15767            f.write_str("_2_VERTEX_INPUT")?;
15768            remaining &= !Self::_2_VERTEX_INPUT.0;
15769            first = false;
15770        }
15771        if remaining & Self::_2_VERTEX_SHADER.0 != 0 {
15772            if !first {
15773                f.write_str(" | ")?;
15774            }
15775            f.write_str("_2_VERTEX_SHADER")?;
15776            remaining &= !Self::_2_VERTEX_SHADER.0;
15777            first = false;
15778        }
15779        if remaining & Self::_2_TESSELLATION_CONTROL_SHADER.0 != 0 {
15780            if !first {
15781                f.write_str(" | ")?;
15782            }
15783            f.write_str("_2_TESSELLATION_CONTROL_SHADER")?;
15784            remaining &= !Self::_2_TESSELLATION_CONTROL_SHADER.0;
15785            first = false;
15786        }
15787        if remaining & Self::_2_TESSELLATION_EVALUATION_SHADER.0 != 0 {
15788            if !first {
15789                f.write_str(" | ")?;
15790            }
15791            f.write_str("_2_TESSELLATION_EVALUATION_SHADER")?;
15792            remaining &= !Self::_2_TESSELLATION_EVALUATION_SHADER.0;
15793            first = false;
15794        }
15795        if remaining & Self::_2_GEOMETRY_SHADER.0 != 0 {
15796            if !first {
15797                f.write_str(" | ")?;
15798            }
15799            f.write_str("_2_GEOMETRY_SHADER")?;
15800            remaining &= !Self::_2_GEOMETRY_SHADER.0;
15801            first = false;
15802        }
15803        if remaining & Self::_2_FRAGMENT_SHADER.0 != 0 {
15804            if !first {
15805                f.write_str(" | ")?;
15806            }
15807            f.write_str("_2_FRAGMENT_SHADER")?;
15808            remaining &= !Self::_2_FRAGMENT_SHADER.0;
15809            first = false;
15810        }
15811        if remaining & Self::_2_EARLY_FRAGMENT_TESTS.0 != 0 {
15812            if !first {
15813                f.write_str(" | ")?;
15814            }
15815            f.write_str("_2_EARLY_FRAGMENT_TESTS")?;
15816            remaining &= !Self::_2_EARLY_FRAGMENT_TESTS.0;
15817            first = false;
15818        }
15819        if remaining & Self::_2_LATE_FRAGMENT_TESTS.0 != 0 {
15820            if !first {
15821                f.write_str(" | ")?;
15822            }
15823            f.write_str("_2_LATE_FRAGMENT_TESTS")?;
15824            remaining &= !Self::_2_LATE_FRAGMENT_TESTS.0;
15825            first = false;
15826        }
15827        if remaining & Self::_2_COLOR_ATTACHMENT_OUTPUT.0 != 0 {
15828            if !first {
15829                f.write_str(" | ")?;
15830            }
15831            f.write_str("_2_COLOR_ATTACHMENT_OUTPUT")?;
15832            remaining &= !Self::_2_COLOR_ATTACHMENT_OUTPUT.0;
15833            first = false;
15834        }
15835        if remaining & Self::_2_COMPUTE_SHADER.0 != 0 {
15836            if !first {
15837                f.write_str(" | ")?;
15838            }
15839            f.write_str("_2_COMPUTE_SHADER")?;
15840            remaining &= !Self::_2_COMPUTE_SHADER.0;
15841            first = false;
15842        }
15843        if remaining & Self::_2_ALL_TRANSFER.0 != 0 {
15844            if !first {
15845                f.write_str(" | ")?;
15846            }
15847            f.write_str("_2_ALL_TRANSFER")?;
15848            remaining &= !Self::_2_ALL_TRANSFER.0;
15849            first = false;
15850        }
15851        if remaining & Self::_2_BOTTOM_OF_PIPE.0 != 0 {
15852            if !first {
15853                f.write_str(" | ")?;
15854            }
15855            f.write_str("_2_BOTTOM_OF_PIPE")?;
15856            remaining &= !Self::_2_BOTTOM_OF_PIPE.0;
15857            first = false;
15858        }
15859        if remaining & Self::_2_HOST.0 != 0 {
15860            if !first {
15861                f.write_str(" | ")?;
15862            }
15863            f.write_str("_2_HOST")?;
15864            remaining &= !Self::_2_HOST.0;
15865            first = false;
15866        }
15867        if remaining & Self::_2_ALL_GRAPHICS.0 != 0 {
15868            if !first {
15869                f.write_str(" | ")?;
15870            }
15871            f.write_str("_2_ALL_GRAPHICS")?;
15872            remaining &= !Self::_2_ALL_GRAPHICS.0;
15873            first = false;
15874        }
15875        if remaining & Self::_2_ALL_COMMANDS.0 != 0 {
15876            if !first {
15877                f.write_str(" | ")?;
15878            }
15879            f.write_str("_2_ALL_COMMANDS")?;
15880            remaining &= !Self::_2_ALL_COMMANDS.0;
15881            first = false;
15882        }
15883        if remaining & Self::_2_COPY.0 != 0 {
15884            if !first {
15885                f.write_str(" | ")?;
15886            }
15887            f.write_str("_2_COPY")?;
15888            remaining &= !Self::_2_COPY.0;
15889            first = false;
15890        }
15891        if remaining & Self::_2_RESOLVE.0 != 0 {
15892            if !first {
15893                f.write_str(" | ")?;
15894            }
15895            f.write_str("_2_RESOLVE")?;
15896            remaining &= !Self::_2_RESOLVE.0;
15897            first = false;
15898        }
15899        if remaining & Self::_2_BLIT.0 != 0 {
15900            if !first {
15901                f.write_str(" | ")?;
15902            }
15903            f.write_str("_2_BLIT")?;
15904            remaining &= !Self::_2_BLIT.0;
15905            first = false;
15906        }
15907        if remaining & Self::_2_CLEAR.0 != 0 {
15908            if !first {
15909                f.write_str(" | ")?;
15910            }
15911            f.write_str("_2_CLEAR")?;
15912            remaining &= !Self::_2_CLEAR.0;
15913            first = false;
15914        }
15915        if remaining & Self::_2_INDEX_INPUT.0 != 0 {
15916            if !first {
15917                f.write_str(" | ")?;
15918            }
15919            f.write_str("_2_INDEX_INPUT")?;
15920            remaining &= !Self::_2_INDEX_INPUT.0;
15921            first = false;
15922        }
15923        if remaining & Self::_2_VERTEX_ATTRIBUTE_INPUT.0 != 0 {
15924            if !first {
15925                f.write_str(" | ")?;
15926            }
15927            f.write_str("_2_VERTEX_ATTRIBUTE_INPUT")?;
15928            remaining &= !Self::_2_VERTEX_ATTRIBUTE_INPUT.0;
15929            first = false;
15930        }
15931        if remaining & Self::_2_PRE_RASTERIZATION_SHADERS.0 != 0 {
15932            if !first {
15933                f.write_str(" | ")?;
15934            }
15935            f.write_str("_2_PRE_RASTERIZATION_SHADERS")?;
15936            remaining &= !Self::_2_PRE_RASTERIZATION_SHADERS.0;
15937            first = false;
15938        }
15939        if remaining & Self::_2_VIDEO_DECODE.0 != 0 {
15940            if !first {
15941                f.write_str(" | ")?;
15942            }
15943            f.write_str("_2_VIDEO_DECODE")?;
15944            remaining &= !Self::_2_VIDEO_DECODE.0;
15945            first = false;
15946        }
15947        if remaining & Self::_2_VIDEO_ENCODE.0 != 0 {
15948            if !first {
15949                f.write_str(" | ")?;
15950            }
15951            f.write_str("_2_VIDEO_ENCODE")?;
15952            remaining &= !Self::_2_VIDEO_ENCODE.0;
15953            first = false;
15954        }
15955        if remaining & Self::_2_TRANSFORM_FEEDBACK.0 != 0 {
15956            if !first {
15957                f.write_str(" | ")?;
15958            }
15959            f.write_str("_2_TRANSFORM_FEEDBACK")?;
15960            remaining &= !Self::_2_TRANSFORM_FEEDBACK.0;
15961            first = false;
15962        }
15963        if remaining & Self::_2_CONDITIONAL_RENDERING.0 != 0 {
15964            if !first {
15965                f.write_str(" | ")?;
15966            }
15967            f.write_str("_2_CONDITIONAL_RENDERING")?;
15968            remaining &= !Self::_2_CONDITIONAL_RENDERING.0;
15969            first = false;
15970        }
15971        if remaining & Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
15972            if !first {
15973                f.write_str(" | ")?;
15974            }
15975            f.write_str("_2_FRAGMENT_SHADING_RATE_ATTACHMENT")?;
15976            remaining &= !Self::_2_FRAGMENT_SHADING_RATE_ATTACHMENT.0;
15977            first = false;
15978        }
15979        if remaining & Self::_2_ACCELERATION_STRUCTURE_BUILD.0 != 0 {
15980            if !first {
15981                f.write_str(" | ")?;
15982            }
15983            f.write_str("_2_ACCELERATION_STRUCTURE_BUILD")?;
15984            remaining &= !Self::_2_ACCELERATION_STRUCTURE_BUILD.0;
15985            first = false;
15986        }
15987        if remaining & Self::_2_RAY_TRACING_SHADER.0 != 0 {
15988            if !first {
15989                f.write_str(" | ")?;
15990            }
15991            f.write_str("_2_RAY_TRACING_SHADER")?;
15992            remaining &= !Self::_2_RAY_TRACING_SHADER.0;
15993            first = false;
15994        }
15995        if remaining & Self::_2_FRAGMENT_DENSITY_PROCESS.0 != 0 {
15996            if !first {
15997                f.write_str(" | ")?;
15998            }
15999            f.write_str("_2_FRAGMENT_DENSITY_PROCESS")?;
16000            remaining &= !Self::_2_FRAGMENT_DENSITY_PROCESS.0;
16001            first = false;
16002        }
16003        if remaining & Self::_2_SUBPASS_SHADER_BIT.0 != 0 {
16004            if !first {
16005                f.write_str(" | ")?;
16006            }
16007            f.write_str("_2_SUBPASS_SHADER_BIT")?;
16008            remaining &= !Self::_2_SUBPASS_SHADER_BIT.0;
16009            first = false;
16010        }
16011        if remaining & Self::_2_INVOCATION_MASK_BIT.0 != 0 {
16012            if !first {
16013                f.write_str(" | ")?;
16014            }
16015            f.write_str("_2_INVOCATION_MASK_BIT")?;
16016            remaining &= !Self::_2_INVOCATION_MASK_BIT.0;
16017            first = false;
16018        }
16019        if remaining & Self::_2_ACCELERATION_STRUCTURE_COPY.0 != 0 {
16020            if !first {
16021                f.write_str(" | ")?;
16022            }
16023            f.write_str("_2_ACCELERATION_STRUCTURE_COPY")?;
16024            remaining &= !Self::_2_ACCELERATION_STRUCTURE_COPY.0;
16025            first = false;
16026        }
16027        if remaining & Self::_2_MICROMAP_BUILD.0 != 0 {
16028            if !first {
16029                f.write_str(" | ")?;
16030            }
16031            f.write_str("_2_MICROMAP_BUILD")?;
16032            remaining &= !Self::_2_MICROMAP_BUILD.0;
16033            first = false;
16034        }
16035        if remaining & Self::_2_CLUSTER_CULLING_SHADER_BIT.0 != 0 {
16036            if !first {
16037                f.write_str(" | ")?;
16038            }
16039            f.write_str("_2_CLUSTER_CULLING_SHADER_BIT")?;
16040            remaining &= !Self::_2_CLUSTER_CULLING_SHADER_BIT.0;
16041            first = false;
16042        }
16043        if remaining & Self::_2_OPTICAL_FLOW.0 != 0 {
16044            if !first {
16045                f.write_str(" | ")?;
16046            }
16047            f.write_str("_2_OPTICAL_FLOW")?;
16048            remaining &= !Self::_2_OPTICAL_FLOW.0;
16049            first = false;
16050        }
16051        if remaining & Self::_2_CONVERT_COOPERATIVE_VECTOR_MATRIX.0 != 0 {
16052            if !first {
16053                f.write_str(" | ")?;
16054            }
16055            f.write_str("_2_CONVERT_COOPERATIVE_VECTOR_MATRIX")?;
16056            remaining &= !Self::_2_CONVERT_COOPERATIVE_VECTOR_MATRIX.0;
16057            first = false;
16058        }
16059        if remaining & Self::_2_DATA_GRAPH_BIT.0 != 0 {
16060            if !first {
16061                f.write_str(" | ")?;
16062            }
16063            f.write_str("_2_DATA_GRAPH_BIT")?;
16064            remaining &= !Self::_2_DATA_GRAPH_BIT.0;
16065            first = false;
16066        }
16067        if remaining & Self::_2_COPY_INDIRECT.0 != 0 {
16068            if !first {
16069                f.write_str(" | ")?;
16070            }
16071            f.write_str("_2_COPY_INDIRECT")?;
16072            remaining &= !Self::_2_COPY_INDIRECT.0;
16073            first = false;
16074        }
16075        if remaining & Self::_2_MEMORY_DECOMPRESSION.0 != 0 {
16076            if !first {
16077                f.write_str(" | ")?;
16078            }
16079            f.write_str("_2_MEMORY_DECOMPRESSION")?;
16080            remaining &= !Self::_2_MEMORY_DECOMPRESSION.0;
16081            first = false;
16082        }
16083        if remaining != 0u64 {
16084            if !first {
16085                f.write_str(" | ")?;
16086            }
16087            write!(f, "{:#x}", remaining)?;
16088        } else if first {
16089            f.write_str("(empty)")?;
16090        }
16091        Ok(())
16092    }
16093}
16094///[`VkPresentGravityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentGravityFlagBitsKHR.html)
16095#[repr(transparent)]
16096#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
16097#[doc(alias = "VkPresentGravityFlagBitsKHR")]
16098pub struct PresentGravityFlagBitsKHR(u32);
16099impl PresentGravityFlagBitsKHR {
16100    #[inline]
16101    pub const fn empty() -> Self {
16102        Self(0u32)
16103    }
16104    #[inline]
16105    pub const fn from_raw(value: u32) -> Self {
16106        Self(value)
16107    }
16108    #[inline]
16109    pub const fn as_raw(self) -> u32 {
16110        self.0
16111    }
16112    #[inline]
16113    pub const fn is_empty(self) -> bool {
16114        self.0 == 0u32
16115    }
16116    #[inline]
16117    pub const fn contains(self, other: Self) -> bool {
16118        (self.0 & other.0) == other.0
16119    }
16120    ///Bit 0.
16121    pub const MIN: Self = Self(1u32);
16122    ///Bit 1.
16123    pub const MAX: Self = Self(2u32);
16124    ///Bit 2.
16125    pub const CENTERED: Self = Self(4u32);
16126}
16127impl core::ops::BitOr for PresentGravityFlagBitsKHR {
16128    type Output = Self;
16129    #[inline]
16130    fn bitor(self, rhs: Self) -> Self {
16131        Self(self.0 | rhs.0)
16132    }
16133}
16134impl core::ops::BitOrAssign for PresentGravityFlagBitsKHR {
16135    #[inline]
16136    fn bitor_assign(&mut self, rhs: Self) {
16137        self.0 |= rhs.0;
16138    }
16139}
16140impl core::ops::BitAnd for PresentGravityFlagBitsKHR {
16141    type Output = Self;
16142    #[inline]
16143    fn bitand(self, rhs: Self) -> Self {
16144        Self(self.0 & rhs.0)
16145    }
16146}
16147impl core::ops::BitAndAssign for PresentGravityFlagBitsKHR {
16148    #[inline]
16149    fn bitand_assign(&mut self, rhs: Self) {
16150        self.0 &= rhs.0;
16151    }
16152}
16153impl core::ops::BitXor for PresentGravityFlagBitsKHR {
16154    type Output = Self;
16155    #[inline]
16156    fn bitxor(self, rhs: Self) -> Self {
16157        Self(self.0 ^ rhs.0)
16158    }
16159}
16160impl core::ops::BitXorAssign for PresentGravityFlagBitsKHR {
16161    #[inline]
16162    fn bitxor_assign(&mut self, rhs: Self) {
16163        self.0 ^= rhs.0;
16164    }
16165}
16166impl core::ops::Not for PresentGravityFlagBitsKHR {
16167    type Output = Self;
16168    #[inline]
16169    fn not(self) -> Self {
16170        Self(!self.0)
16171    }
16172}
16173impl core::fmt::Debug for PresentGravityFlagBitsKHR {
16174    #[allow(unused_mut, unused_variables)]
16175    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16176        let mut first = true;
16177        let mut remaining = self.0;
16178        if remaining & Self::MIN.0 != 0 {
16179            if !first {
16180                f.write_str(" | ")?;
16181            }
16182            f.write_str("MIN")?;
16183            remaining &= !Self::MIN.0;
16184            first = false;
16185        }
16186        if remaining & Self::MAX.0 != 0 {
16187            if !first {
16188                f.write_str(" | ")?;
16189            }
16190            f.write_str("MAX")?;
16191            remaining &= !Self::MAX.0;
16192            first = false;
16193        }
16194        if remaining & Self::CENTERED.0 != 0 {
16195            if !first {
16196                f.write_str(" | ")?;
16197            }
16198            f.write_str("CENTERED")?;
16199            remaining &= !Self::CENTERED.0;
16200            first = false;
16201        }
16202        if remaining != 0u32 {
16203            if !first {
16204                f.write_str(" | ")?;
16205            }
16206            write!(f, "{:#x}", remaining)?;
16207        } else if first {
16208            f.write_str("(empty)")?;
16209        }
16210        Ok(())
16211    }
16212}
16213///[`VkPresentScalingFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentScalingFlagBitsKHR.html)
16214#[repr(transparent)]
16215#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
16216#[doc(alias = "VkPresentScalingFlagBitsKHR")]
16217pub struct PresentScalingFlagBitsKHR(u32);
16218impl PresentScalingFlagBitsKHR {
16219    #[inline]
16220    pub const fn empty() -> Self {
16221        Self(0u32)
16222    }
16223    #[inline]
16224    pub const fn from_raw(value: u32) -> Self {
16225        Self(value)
16226    }
16227    #[inline]
16228    pub const fn as_raw(self) -> u32 {
16229        self.0
16230    }
16231    #[inline]
16232    pub const fn is_empty(self) -> bool {
16233        self.0 == 0u32
16234    }
16235    #[inline]
16236    pub const fn contains(self, other: Self) -> bool {
16237        (self.0 & other.0) == other.0
16238    }
16239    ///Bit 0.
16240    pub const ONE_TO_ONE: Self = Self(1u32);
16241    ///Bit 1.
16242    pub const ASPECT_RATIO_STRETCH: Self = Self(2u32);
16243    ///Bit 2.
16244    pub const STRETCH: Self = Self(4u32);
16245}
16246impl core::ops::BitOr for PresentScalingFlagBitsKHR {
16247    type Output = Self;
16248    #[inline]
16249    fn bitor(self, rhs: Self) -> Self {
16250        Self(self.0 | rhs.0)
16251    }
16252}
16253impl core::ops::BitOrAssign for PresentScalingFlagBitsKHR {
16254    #[inline]
16255    fn bitor_assign(&mut self, rhs: Self) {
16256        self.0 |= rhs.0;
16257    }
16258}
16259impl core::ops::BitAnd for PresentScalingFlagBitsKHR {
16260    type Output = Self;
16261    #[inline]
16262    fn bitand(self, rhs: Self) -> Self {
16263        Self(self.0 & rhs.0)
16264    }
16265}
16266impl core::ops::BitAndAssign for PresentScalingFlagBitsKHR {
16267    #[inline]
16268    fn bitand_assign(&mut self, rhs: Self) {
16269        self.0 &= rhs.0;
16270    }
16271}
16272impl core::ops::BitXor for PresentScalingFlagBitsKHR {
16273    type Output = Self;
16274    #[inline]
16275    fn bitxor(self, rhs: Self) -> Self {
16276        Self(self.0 ^ rhs.0)
16277    }
16278}
16279impl core::ops::BitXorAssign for PresentScalingFlagBitsKHR {
16280    #[inline]
16281    fn bitxor_assign(&mut self, rhs: Self) {
16282        self.0 ^= rhs.0;
16283    }
16284}
16285impl core::ops::Not for PresentScalingFlagBitsKHR {
16286    type Output = Self;
16287    #[inline]
16288    fn not(self) -> Self {
16289        Self(!self.0)
16290    }
16291}
16292impl core::fmt::Debug for PresentScalingFlagBitsKHR {
16293    #[allow(unused_mut, unused_variables)]
16294    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16295        let mut first = true;
16296        let mut remaining = self.0;
16297        if remaining & Self::ONE_TO_ONE.0 != 0 {
16298            if !first {
16299                f.write_str(" | ")?;
16300            }
16301            f.write_str("ONE_TO_ONE")?;
16302            remaining &= !Self::ONE_TO_ONE.0;
16303            first = false;
16304        }
16305        if remaining & Self::ASPECT_RATIO_STRETCH.0 != 0 {
16306            if !first {
16307                f.write_str(" | ")?;
16308            }
16309            f.write_str("ASPECT_RATIO_STRETCH")?;
16310            remaining &= !Self::ASPECT_RATIO_STRETCH.0;
16311            first = false;
16312        }
16313        if remaining & Self::STRETCH.0 != 0 {
16314            if !first {
16315                f.write_str(" | ")?;
16316            }
16317            f.write_str("STRETCH")?;
16318            remaining &= !Self::STRETCH.0;
16319            first = false;
16320        }
16321        if remaining != 0u32 {
16322            if !first {
16323                f.write_str(" | ")?;
16324            }
16325            write!(f, "{:#x}", remaining)?;
16326        } else if first {
16327            f.write_str("(empty)")?;
16328        }
16329        Ok(())
16330    }
16331}
16332///[`VkPresentStageFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageFlagBitsEXT.html)
16333#[repr(transparent)]
16334#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
16335#[doc(alias = "VkPresentStageFlagBitsEXT")]
16336pub struct PresentStageFlagBitsEXT(u32);
16337impl PresentStageFlagBitsEXT {
16338    #[inline]
16339    pub const fn empty() -> Self {
16340        Self(0u32)
16341    }
16342    #[inline]
16343    pub const fn from_raw(value: u32) -> Self {
16344        Self(value)
16345    }
16346    #[inline]
16347    pub const fn as_raw(self) -> u32 {
16348        self.0
16349    }
16350    #[inline]
16351    pub const fn is_empty(self) -> bool {
16352        self.0 == 0u32
16353    }
16354    #[inline]
16355    pub const fn contains(self, other: Self) -> bool {
16356        (self.0 & other.0) == other.0
16357    }
16358    ///Bit 0.
16359    pub const QUEUE_OPERATIONS_END: Self = Self(1u32);
16360    ///Bit 1.
16361    pub const REQUEST_DEQUEUED: Self = Self(2u32);
16362    ///Bit 2.
16363    pub const IMAGE_FIRST_PIXEL_OUT: Self = Self(4u32);
16364    ///Bit 3.
16365    pub const IMAGE_FIRST_PIXEL_VISIBLE: Self = Self(8u32);
16366}
16367impl core::ops::BitOr for PresentStageFlagBitsEXT {
16368    type Output = Self;
16369    #[inline]
16370    fn bitor(self, rhs: Self) -> Self {
16371        Self(self.0 | rhs.0)
16372    }
16373}
16374impl core::ops::BitOrAssign for PresentStageFlagBitsEXT {
16375    #[inline]
16376    fn bitor_assign(&mut self, rhs: Self) {
16377        self.0 |= rhs.0;
16378    }
16379}
16380impl core::ops::BitAnd for PresentStageFlagBitsEXT {
16381    type Output = Self;
16382    #[inline]
16383    fn bitand(self, rhs: Self) -> Self {
16384        Self(self.0 & rhs.0)
16385    }
16386}
16387impl core::ops::BitAndAssign for PresentStageFlagBitsEXT {
16388    #[inline]
16389    fn bitand_assign(&mut self, rhs: Self) {
16390        self.0 &= rhs.0;
16391    }
16392}
16393impl core::ops::BitXor for PresentStageFlagBitsEXT {
16394    type Output = Self;
16395    #[inline]
16396    fn bitxor(self, rhs: Self) -> Self {
16397        Self(self.0 ^ rhs.0)
16398    }
16399}
16400impl core::ops::BitXorAssign for PresentStageFlagBitsEXT {
16401    #[inline]
16402    fn bitxor_assign(&mut self, rhs: Self) {
16403        self.0 ^= rhs.0;
16404    }
16405}
16406impl core::ops::Not for PresentStageFlagBitsEXT {
16407    type Output = Self;
16408    #[inline]
16409    fn not(self) -> Self {
16410        Self(!self.0)
16411    }
16412}
16413impl core::fmt::Debug for PresentStageFlagBitsEXT {
16414    #[allow(unused_mut, unused_variables)]
16415    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16416        let mut first = true;
16417        let mut remaining = self.0;
16418        if remaining & Self::QUEUE_OPERATIONS_END.0 != 0 {
16419            if !first {
16420                f.write_str(" | ")?;
16421            }
16422            f.write_str("QUEUE_OPERATIONS_END")?;
16423            remaining &= !Self::QUEUE_OPERATIONS_END.0;
16424            first = false;
16425        }
16426        if remaining & Self::REQUEST_DEQUEUED.0 != 0 {
16427            if !first {
16428                f.write_str(" | ")?;
16429            }
16430            f.write_str("REQUEST_DEQUEUED")?;
16431            remaining &= !Self::REQUEST_DEQUEUED.0;
16432            first = false;
16433        }
16434        if remaining & Self::IMAGE_FIRST_PIXEL_OUT.0 != 0 {
16435            if !first {
16436                f.write_str(" | ")?;
16437            }
16438            f.write_str("IMAGE_FIRST_PIXEL_OUT")?;
16439            remaining &= !Self::IMAGE_FIRST_PIXEL_OUT.0;
16440            first = false;
16441        }
16442        if remaining & Self::IMAGE_FIRST_PIXEL_VISIBLE.0 != 0 {
16443            if !first {
16444                f.write_str(" | ")?;
16445            }
16446            f.write_str("IMAGE_FIRST_PIXEL_VISIBLE")?;
16447            remaining &= !Self::IMAGE_FIRST_PIXEL_VISIBLE.0;
16448            first = false;
16449        }
16450        if remaining != 0u32 {
16451            if !first {
16452                f.write_str(" | ")?;
16453            }
16454            write!(f, "{:#x}", remaining)?;
16455        } else if first {
16456            f.write_str("(empty)")?;
16457        }
16458        Ok(())
16459    }
16460}
16461///[`VkPresentTimingInfoFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoFlagBitsEXT.html)
16462#[repr(transparent)]
16463#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
16464#[doc(alias = "VkPresentTimingInfoFlagBitsEXT")]
16465pub struct PresentTimingInfoFlagBitsEXT(u32);
16466impl PresentTimingInfoFlagBitsEXT {
16467    #[inline]
16468    pub const fn empty() -> Self {
16469        Self(0u32)
16470    }
16471    #[inline]
16472    pub const fn from_raw(value: u32) -> Self {
16473        Self(value)
16474    }
16475    #[inline]
16476    pub const fn as_raw(self) -> u32 {
16477        self.0
16478    }
16479    #[inline]
16480    pub const fn is_empty(self) -> bool {
16481        self.0 == 0u32
16482    }
16483    #[inline]
16484    pub const fn contains(self, other: Self) -> bool {
16485        (self.0 & other.0) == other.0
16486    }
16487    ///Bit 0.
16488    pub const PRESENT_AT_RELATIVE_TIME: Self = Self(1u32);
16489    ///Bit 1.
16490    pub const PRESENT_AT_NEAREST_REFRESH_CYCLE: Self = Self(2u32);
16491}
16492impl core::ops::BitOr for PresentTimingInfoFlagBitsEXT {
16493    type Output = Self;
16494    #[inline]
16495    fn bitor(self, rhs: Self) -> Self {
16496        Self(self.0 | rhs.0)
16497    }
16498}
16499impl core::ops::BitOrAssign for PresentTimingInfoFlagBitsEXT {
16500    #[inline]
16501    fn bitor_assign(&mut self, rhs: Self) {
16502        self.0 |= rhs.0;
16503    }
16504}
16505impl core::ops::BitAnd for PresentTimingInfoFlagBitsEXT {
16506    type Output = Self;
16507    #[inline]
16508    fn bitand(self, rhs: Self) -> Self {
16509        Self(self.0 & rhs.0)
16510    }
16511}
16512impl core::ops::BitAndAssign for PresentTimingInfoFlagBitsEXT {
16513    #[inline]
16514    fn bitand_assign(&mut self, rhs: Self) {
16515        self.0 &= rhs.0;
16516    }
16517}
16518impl core::ops::BitXor for PresentTimingInfoFlagBitsEXT {
16519    type Output = Self;
16520    #[inline]
16521    fn bitxor(self, rhs: Self) -> Self {
16522        Self(self.0 ^ rhs.0)
16523    }
16524}
16525impl core::ops::BitXorAssign for PresentTimingInfoFlagBitsEXT {
16526    #[inline]
16527    fn bitxor_assign(&mut self, rhs: Self) {
16528        self.0 ^= rhs.0;
16529    }
16530}
16531impl core::ops::Not for PresentTimingInfoFlagBitsEXT {
16532    type Output = Self;
16533    #[inline]
16534    fn not(self) -> Self {
16535        Self(!self.0)
16536    }
16537}
16538impl core::fmt::Debug for PresentTimingInfoFlagBitsEXT {
16539    #[allow(unused_mut, unused_variables)]
16540    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16541        let mut first = true;
16542        let mut remaining = self.0;
16543        if remaining & Self::PRESENT_AT_RELATIVE_TIME.0 != 0 {
16544            if !first {
16545                f.write_str(" | ")?;
16546            }
16547            f.write_str("PRESENT_AT_RELATIVE_TIME")?;
16548            remaining &= !Self::PRESENT_AT_RELATIVE_TIME.0;
16549            first = false;
16550        }
16551        if remaining & Self::PRESENT_AT_NEAREST_REFRESH_CYCLE.0 != 0 {
16552            if !first {
16553                f.write_str(" | ")?;
16554            }
16555            f.write_str("PRESENT_AT_NEAREST_REFRESH_CYCLE")?;
16556            remaining &= !Self::PRESENT_AT_NEAREST_REFRESH_CYCLE.0;
16557            first = false;
16558        }
16559        if remaining != 0u32 {
16560            if !first {
16561                f.write_str(" | ")?;
16562            }
16563            write!(f, "{:#x}", remaining)?;
16564        } else if first {
16565            f.write_str("(empty)")?;
16566        }
16567        Ok(())
16568    }
16569}
16570///[`VkPrivateDataSlotCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateFlagBits.html)
16571#[repr(transparent)]
16572#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
16573#[doc(alias = "VkPrivateDataSlotCreateFlagBits")]
16574pub struct PrivateDataSlotCreateFlagBits(u32);
16575impl PrivateDataSlotCreateFlagBits {
16576    #[inline]
16577    pub const fn empty() -> Self {
16578        Self(0u32)
16579    }
16580    #[inline]
16581    pub const fn from_raw(value: u32) -> Self {
16582        Self(value)
16583    }
16584    #[inline]
16585    pub const fn as_raw(self) -> u32 {
16586        self.0
16587    }
16588    #[inline]
16589    pub const fn is_empty(self) -> bool {
16590        self.0 == 0u32
16591    }
16592    #[inline]
16593    pub const fn contains(self, other: Self) -> bool {
16594        (self.0 & other.0) == other.0
16595    }
16596}
16597impl core::ops::BitOr for PrivateDataSlotCreateFlagBits {
16598    type Output = Self;
16599    #[inline]
16600    fn bitor(self, rhs: Self) -> Self {
16601        Self(self.0 | rhs.0)
16602    }
16603}
16604impl core::ops::BitOrAssign for PrivateDataSlotCreateFlagBits {
16605    #[inline]
16606    fn bitor_assign(&mut self, rhs: Self) {
16607        self.0 |= rhs.0;
16608    }
16609}
16610impl core::ops::BitAnd for PrivateDataSlotCreateFlagBits {
16611    type Output = Self;
16612    #[inline]
16613    fn bitand(self, rhs: Self) -> Self {
16614        Self(self.0 & rhs.0)
16615    }
16616}
16617impl core::ops::BitAndAssign for PrivateDataSlotCreateFlagBits {
16618    #[inline]
16619    fn bitand_assign(&mut self, rhs: Self) {
16620        self.0 &= rhs.0;
16621    }
16622}
16623impl core::ops::BitXor for PrivateDataSlotCreateFlagBits {
16624    type Output = Self;
16625    #[inline]
16626    fn bitxor(self, rhs: Self) -> Self {
16627        Self(self.0 ^ rhs.0)
16628    }
16629}
16630impl core::ops::BitXorAssign for PrivateDataSlotCreateFlagBits {
16631    #[inline]
16632    fn bitxor_assign(&mut self, rhs: Self) {
16633        self.0 ^= rhs.0;
16634    }
16635}
16636impl core::ops::Not for PrivateDataSlotCreateFlagBits {
16637    type Output = Self;
16638    #[inline]
16639    fn not(self) -> Self {
16640        Self(!self.0)
16641    }
16642}
16643impl core::fmt::Debug for PrivateDataSlotCreateFlagBits {
16644    #[allow(unused_mut, unused_variables)]
16645    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16646        let mut first = true;
16647        let mut remaining = self.0;
16648        if remaining != 0u32 {
16649            if !first {
16650                f.write_str(" | ")?;
16651            }
16652            write!(f, "{:#x}", remaining)?;
16653        } else if first {
16654            f.write_str("(empty)")?;
16655        }
16656        Ok(())
16657    }
16658}
16659///[`VkQueryControlFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryControlFlagBits.html)
16660#[repr(transparent)]
16661#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
16662#[doc(alias = "VkQueryControlFlagBits")]
16663pub struct QueryControlFlagBits(u32);
16664impl QueryControlFlagBits {
16665    #[inline]
16666    pub const fn empty() -> Self {
16667        Self(0u32)
16668    }
16669    #[inline]
16670    pub const fn from_raw(value: u32) -> Self {
16671        Self(value)
16672    }
16673    #[inline]
16674    pub const fn as_raw(self) -> u32 {
16675        self.0
16676    }
16677    #[inline]
16678    pub const fn is_empty(self) -> bool {
16679        self.0 == 0u32
16680    }
16681    #[inline]
16682    pub const fn contains(self, other: Self) -> bool {
16683        (self.0 & other.0) == other.0
16684    }
16685    ///Bit 0.
16686    pub const PRECISE: Self = Self(1u32);
16687}
16688impl core::ops::BitOr for QueryControlFlagBits {
16689    type Output = Self;
16690    #[inline]
16691    fn bitor(self, rhs: Self) -> Self {
16692        Self(self.0 | rhs.0)
16693    }
16694}
16695impl core::ops::BitOrAssign for QueryControlFlagBits {
16696    #[inline]
16697    fn bitor_assign(&mut self, rhs: Self) {
16698        self.0 |= rhs.0;
16699    }
16700}
16701impl core::ops::BitAnd for QueryControlFlagBits {
16702    type Output = Self;
16703    #[inline]
16704    fn bitand(self, rhs: Self) -> Self {
16705        Self(self.0 & rhs.0)
16706    }
16707}
16708impl core::ops::BitAndAssign for QueryControlFlagBits {
16709    #[inline]
16710    fn bitand_assign(&mut self, rhs: Self) {
16711        self.0 &= rhs.0;
16712    }
16713}
16714impl core::ops::BitXor for QueryControlFlagBits {
16715    type Output = Self;
16716    #[inline]
16717    fn bitxor(self, rhs: Self) -> Self {
16718        Self(self.0 ^ rhs.0)
16719    }
16720}
16721impl core::ops::BitXorAssign for QueryControlFlagBits {
16722    #[inline]
16723    fn bitxor_assign(&mut self, rhs: Self) {
16724        self.0 ^= rhs.0;
16725    }
16726}
16727impl core::ops::Not for QueryControlFlagBits {
16728    type Output = Self;
16729    #[inline]
16730    fn not(self) -> Self {
16731        Self(!self.0)
16732    }
16733}
16734impl core::fmt::Debug for QueryControlFlagBits {
16735    #[allow(unused_mut, unused_variables)]
16736    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16737        let mut first = true;
16738        let mut remaining = self.0;
16739        if remaining & Self::PRECISE.0 != 0 {
16740            if !first {
16741                f.write_str(" | ")?;
16742            }
16743            f.write_str("PRECISE")?;
16744            remaining &= !Self::PRECISE.0;
16745            first = false;
16746        }
16747        if remaining != 0u32 {
16748            if !first {
16749                f.write_str(" | ")?;
16750            }
16751            write!(f, "{:#x}", remaining)?;
16752        } else if first {
16753            f.write_str("(empty)")?;
16754        }
16755        Ok(())
16756    }
16757}
16758///[`VkQueryPipelineStatisticFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPipelineStatisticFlagBits.html)
16759#[repr(transparent)]
16760#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
16761#[doc(alias = "VkQueryPipelineStatisticFlagBits")]
16762pub struct QueryPipelineStatisticFlagBits(u32);
16763impl QueryPipelineStatisticFlagBits {
16764    #[inline]
16765    pub const fn empty() -> Self {
16766        Self(0u32)
16767    }
16768    #[inline]
16769    pub const fn from_raw(value: u32) -> Self {
16770        Self(value)
16771    }
16772    #[inline]
16773    pub const fn as_raw(self) -> u32 {
16774        self.0
16775    }
16776    #[inline]
16777    pub const fn is_empty(self) -> bool {
16778        self.0 == 0u32
16779    }
16780    #[inline]
16781    pub const fn contains(self, other: Self) -> bool {
16782        (self.0 & other.0) == other.0
16783    }
16784    ///Bit 0.
16785    pub const INPUT_ASSEMBLY_VERTICES: Self = Self(1u32);
16786    ///Bit 1.
16787    pub const INPUT_ASSEMBLY_PRIMITIVES: Self = Self(2u32);
16788    ///Bit 2.
16789    pub const VERTEX_SHADER_INVOCATIONS: Self = Self(4u32);
16790    ///Bit 3.
16791    pub const GEOMETRY_SHADER_INVOCATIONS: Self = Self(8u32);
16792    ///Bit 4.
16793    pub const GEOMETRY_SHADER_PRIMITIVES: Self = Self(16u32);
16794    ///Bit 5.
16795    pub const CLIPPING_INVOCATIONS: Self = Self(32u32);
16796    ///Bit 6.
16797    pub const CLIPPING_PRIMITIVES: Self = Self(64u32);
16798    ///Bit 7.
16799    pub const FRAGMENT_SHADER_INVOCATIONS: Self = Self(128u32);
16800    ///Bit 8.
16801    pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = Self(256u32);
16802    ///Bit 9.
16803    pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = Self(512u32);
16804    ///Bit 10.
16805    pub const COMPUTE_SHADER_INVOCATIONS: Self = Self(1024u32);
16806    ///Bit 11.
16807    pub const TASK_SHADER_INVOCATIONS: Self = Self(2048u32);
16808    ///Bit 12.
16809    pub const MESH_SHADER_INVOCATIONS: Self = Self(4096u32);
16810    ///Bit 13.
16811    pub const CLUSTER_CULLING_SHADER_INVOCATIONS_BIT: Self = Self(8192u32);
16812}
16813impl core::ops::BitOr for QueryPipelineStatisticFlagBits {
16814    type Output = Self;
16815    #[inline]
16816    fn bitor(self, rhs: Self) -> Self {
16817        Self(self.0 | rhs.0)
16818    }
16819}
16820impl core::ops::BitOrAssign for QueryPipelineStatisticFlagBits {
16821    #[inline]
16822    fn bitor_assign(&mut self, rhs: Self) {
16823        self.0 |= rhs.0;
16824    }
16825}
16826impl core::ops::BitAnd for QueryPipelineStatisticFlagBits {
16827    type Output = Self;
16828    #[inline]
16829    fn bitand(self, rhs: Self) -> Self {
16830        Self(self.0 & rhs.0)
16831    }
16832}
16833impl core::ops::BitAndAssign for QueryPipelineStatisticFlagBits {
16834    #[inline]
16835    fn bitand_assign(&mut self, rhs: Self) {
16836        self.0 &= rhs.0;
16837    }
16838}
16839impl core::ops::BitXor for QueryPipelineStatisticFlagBits {
16840    type Output = Self;
16841    #[inline]
16842    fn bitxor(self, rhs: Self) -> Self {
16843        Self(self.0 ^ rhs.0)
16844    }
16845}
16846impl core::ops::BitXorAssign for QueryPipelineStatisticFlagBits {
16847    #[inline]
16848    fn bitxor_assign(&mut self, rhs: Self) {
16849        self.0 ^= rhs.0;
16850    }
16851}
16852impl core::ops::Not for QueryPipelineStatisticFlagBits {
16853    type Output = Self;
16854    #[inline]
16855    fn not(self) -> Self {
16856        Self(!self.0)
16857    }
16858}
16859impl core::fmt::Debug for QueryPipelineStatisticFlagBits {
16860    #[allow(unused_mut, unused_variables)]
16861    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
16862        let mut first = true;
16863        let mut remaining = self.0;
16864        if remaining & Self::INPUT_ASSEMBLY_VERTICES.0 != 0 {
16865            if !first {
16866                f.write_str(" | ")?;
16867            }
16868            f.write_str("INPUT_ASSEMBLY_VERTICES")?;
16869            remaining &= !Self::INPUT_ASSEMBLY_VERTICES.0;
16870            first = false;
16871        }
16872        if remaining & Self::INPUT_ASSEMBLY_PRIMITIVES.0 != 0 {
16873            if !first {
16874                f.write_str(" | ")?;
16875            }
16876            f.write_str("INPUT_ASSEMBLY_PRIMITIVES")?;
16877            remaining &= !Self::INPUT_ASSEMBLY_PRIMITIVES.0;
16878            first = false;
16879        }
16880        if remaining & Self::VERTEX_SHADER_INVOCATIONS.0 != 0 {
16881            if !first {
16882                f.write_str(" | ")?;
16883            }
16884            f.write_str("VERTEX_SHADER_INVOCATIONS")?;
16885            remaining &= !Self::VERTEX_SHADER_INVOCATIONS.0;
16886            first = false;
16887        }
16888        if remaining & Self::GEOMETRY_SHADER_INVOCATIONS.0 != 0 {
16889            if !first {
16890                f.write_str(" | ")?;
16891            }
16892            f.write_str("GEOMETRY_SHADER_INVOCATIONS")?;
16893            remaining &= !Self::GEOMETRY_SHADER_INVOCATIONS.0;
16894            first = false;
16895        }
16896        if remaining & Self::GEOMETRY_SHADER_PRIMITIVES.0 != 0 {
16897            if !first {
16898                f.write_str(" | ")?;
16899            }
16900            f.write_str("GEOMETRY_SHADER_PRIMITIVES")?;
16901            remaining &= !Self::GEOMETRY_SHADER_PRIMITIVES.0;
16902            first = false;
16903        }
16904        if remaining & Self::CLIPPING_INVOCATIONS.0 != 0 {
16905            if !first {
16906                f.write_str(" | ")?;
16907            }
16908            f.write_str("CLIPPING_INVOCATIONS")?;
16909            remaining &= !Self::CLIPPING_INVOCATIONS.0;
16910            first = false;
16911        }
16912        if remaining & Self::CLIPPING_PRIMITIVES.0 != 0 {
16913            if !first {
16914                f.write_str(" | ")?;
16915            }
16916            f.write_str("CLIPPING_PRIMITIVES")?;
16917            remaining &= !Self::CLIPPING_PRIMITIVES.0;
16918            first = false;
16919        }
16920        if remaining & Self::FRAGMENT_SHADER_INVOCATIONS.0 != 0 {
16921            if !first {
16922                f.write_str(" | ")?;
16923            }
16924            f.write_str("FRAGMENT_SHADER_INVOCATIONS")?;
16925            remaining &= !Self::FRAGMENT_SHADER_INVOCATIONS.0;
16926            first = false;
16927        }
16928        if remaining & Self::TESSELLATION_CONTROL_SHADER_PATCHES.0 != 0 {
16929            if !first {
16930                f.write_str(" | ")?;
16931            }
16932            f.write_str("TESSELLATION_CONTROL_SHADER_PATCHES")?;
16933            remaining &= !Self::TESSELLATION_CONTROL_SHADER_PATCHES.0;
16934            first = false;
16935        }
16936        if remaining & Self::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0 != 0 {
16937            if !first {
16938                f.write_str(" | ")?;
16939            }
16940            f.write_str("TESSELLATION_EVALUATION_SHADER_INVOCATIONS")?;
16941            remaining &= !Self::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0;
16942            first = false;
16943        }
16944        if remaining & Self::COMPUTE_SHADER_INVOCATIONS.0 != 0 {
16945            if !first {
16946                f.write_str(" | ")?;
16947            }
16948            f.write_str("COMPUTE_SHADER_INVOCATIONS")?;
16949            remaining &= !Self::COMPUTE_SHADER_INVOCATIONS.0;
16950            first = false;
16951        }
16952        if remaining & Self::TASK_SHADER_INVOCATIONS.0 != 0 {
16953            if !first {
16954                f.write_str(" | ")?;
16955            }
16956            f.write_str("TASK_SHADER_INVOCATIONS")?;
16957            remaining &= !Self::TASK_SHADER_INVOCATIONS.0;
16958            first = false;
16959        }
16960        if remaining & Self::MESH_SHADER_INVOCATIONS.0 != 0 {
16961            if !first {
16962                f.write_str(" | ")?;
16963            }
16964            f.write_str("MESH_SHADER_INVOCATIONS")?;
16965            remaining &= !Self::MESH_SHADER_INVOCATIONS.0;
16966            first = false;
16967        }
16968        if remaining & Self::CLUSTER_CULLING_SHADER_INVOCATIONS_BIT.0 != 0 {
16969            if !first {
16970                f.write_str(" | ")?;
16971            }
16972            f.write_str("CLUSTER_CULLING_SHADER_INVOCATIONS_BIT")?;
16973            remaining &= !Self::CLUSTER_CULLING_SHADER_INVOCATIONS_BIT.0;
16974            first = false;
16975        }
16976        if remaining != 0u32 {
16977            if !first {
16978                f.write_str(" | ")?;
16979            }
16980            write!(f, "{:#x}", remaining)?;
16981        } else if first {
16982            f.write_str("(empty)")?;
16983        }
16984        Ok(())
16985    }
16986}
16987///[`VkQueryPoolCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateFlagBits.html)
16988#[repr(transparent)]
16989#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
16990#[doc(alias = "VkQueryPoolCreateFlagBits")]
16991pub struct QueryPoolCreateFlagBits(u32);
16992impl QueryPoolCreateFlagBits {
16993    #[inline]
16994    pub const fn empty() -> Self {
16995        Self(0u32)
16996    }
16997    #[inline]
16998    pub const fn from_raw(value: u32) -> Self {
16999        Self(value)
17000    }
17001    #[inline]
17002    pub const fn as_raw(self) -> u32 {
17003        self.0
17004    }
17005    #[inline]
17006    pub const fn is_empty(self) -> bool {
17007        self.0 == 0u32
17008    }
17009    #[inline]
17010    pub const fn contains(self, other: Self) -> bool {
17011        (self.0 & other.0) == other.0
17012    }
17013    ///Bit 0.
17014    pub const RESET: Self = Self(1u32);
17015}
17016impl core::ops::BitOr for QueryPoolCreateFlagBits {
17017    type Output = Self;
17018    #[inline]
17019    fn bitor(self, rhs: Self) -> Self {
17020        Self(self.0 | rhs.0)
17021    }
17022}
17023impl core::ops::BitOrAssign for QueryPoolCreateFlagBits {
17024    #[inline]
17025    fn bitor_assign(&mut self, rhs: Self) {
17026        self.0 |= rhs.0;
17027    }
17028}
17029impl core::ops::BitAnd for QueryPoolCreateFlagBits {
17030    type Output = Self;
17031    #[inline]
17032    fn bitand(self, rhs: Self) -> Self {
17033        Self(self.0 & rhs.0)
17034    }
17035}
17036impl core::ops::BitAndAssign for QueryPoolCreateFlagBits {
17037    #[inline]
17038    fn bitand_assign(&mut self, rhs: Self) {
17039        self.0 &= rhs.0;
17040    }
17041}
17042impl core::ops::BitXor for QueryPoolCreateFlagBits {
17043    type Output = Self;
17044    #[inline]
17045    fn bitxor(self, rhs: Self) -> Self {
17046        Self(self.0 ^ rhs.0)
17047    }
17048}
17049impl core::ops::BitXorAssign for QueryPoolCreateFlagBits {
17050    #[inline]
17051    fn bitxor_assign(&mut self, rhs: Self) {
17052        self.0 ^= rhs.0;
17053    }
17054}
17055impl core::ops::Not for QueryPoolCreateFlagBits {
17056    type Output = Self;
17057    #[inline]
17058    fn not(self) -> Self {
17059        Self(!self.0)
17060    }
17061}
17062impl core::fmt::Debug for QueryPoolCreateFlagBits {
17063    #[allow(unused_mut, unused_variables)]
17064    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17065        let mut first = true;
17066        let mut remaining = self.0;
17067        if remaining & Self::RESET.0 != 0 {
17068            if !first {
17069                f.write_str(" | ")?;
17070            }
17071            f.write_str("RESET")?;
17072            remaining &= !Self::RESET.0;
17073            first = false;
17074        }
17075        if remaining != 0u32 {
17076            if !first {
17077                f.write_str(" | ")?;
17078            }
17079            write!(f, "{:#x}", remaining)?;
17080        } else if first {
17081            f.write_str("(empty)")?;
17082        }
17083        Ok(())
17084    }
17085}
17086///[`VkQueryResultFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultFlagBits.html)
17087#[repr(transparent)]
17088#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
17089#[doc(alias = "VkQueryResultFlagBits")]
17090pub struct QueryResultFlagBits(u32);
17091impl QueryResultFlagBits {
17092    #[inline]
17093    pub const fn empty() -> Self {
17094        Self(0u32)
17095    }
17096    #[inline]
17097    pub const fn from_raw(value: u32) -> Self {
17098        Self(value)
17099    }
17100    #[inline]
17101    pub const fn as_raw(self) -> u32 {
17102        self.0
17103    }
17104    #[inline]
17105    pub const fn is_empty(self) -> bool {
17106        self.0 == 0u32
17107    }
17108    #[inline]
17109    pub const fn contains(self, other: Self) -> bool {
17110        (self.0 & other.0) == other.0
17111    }
17112    ///Bit 0.
17113    pub const _64: Self = Self(1u32);
17114    ///Bit 1.
17115    pub const WAIT: Self = Self(2u32);
17116    ///Bit 2.
17117    pub const WITH_AVAILABILITY: Self = Self(4u32);
17118    ///Bit 3.
17119    pub const PARTIAL: Self = Self(8u32);
17120    ///Bit 4.
17121    pub const WITH_STATUS: Self = Self(16u32);
17122}
17123impl core::ops::BitOr for QueryResultFlagBits {
17124    type Output = Self;
17125    #[inline]
17126    fn bitor(self, rhs: Self) -> Self {
17127        Self(self.0 | rhs.0)
17128    }
17129}
17130impl core::ops::BitOrAssign for QueryResultFlagBits {
17131    #[inline]
17132    fn bitor_assign(&mut self, rhs: Self) {
17133        self.0 |= rhs.0;
17134    }
17135}
17136impl core::ops::BitAnd for QueryResultFlagBits {
17137    type Output = Self;
17138    #[inline]
17139    fn bitand(self, rhs: Self) -> Self {
17140        Self(self.0 & rhs.0)
17141    }
17142}
17143impl core::ops::BitAndAssign for QueryResultFlagBits {
17144    #[inline]
17145    fn bitand_assign(&mut self, rhs: Self) {
17146        self.0 &= rhs.0;
17147    }
17148}
17149impl core::ops::BitXor for QueryResultFlagBits {
17150    type Output = Self;
17151    #[inline]
17152    fn bitxor(self, rhs: Self) -> Self {
17153        Self(self.0 ^ rhs.0)
17154    }
17155}
17156impl core::ops::BitXorAssign for QueryResultFlagBits {
17157    #[inline]
17158    fn bitxor_assign(&mut self, rhs: Self) {
17159        self.0 ^= rhs.0;
17160    }
17161}
17162impl core::ops::Not for QueryResultFlagBits {
17163    type Output = Self;
17164    #[inline]
17165    fn not(self) -> Self {
17166        Self(!self.0)
17167    }
17168}
17169impl core::fmt::Debug for QueryResultFlagBits {
17170    #[allow(unused_mut, unused_variables)]
17171    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17172        let mut first = true;
17173        let mut remaining = self.0;
17174        if remaining & Self::_64.0 != 0 {
17175            if !first {
17176                f.write_str(" | ")?;
17177            }
17178            f.write_str("_64")?;
17179            remaining &= !Self::_64.0;
17180            first = false;
17181        }
17182        if remaining & Self::WAIT.0 != 0 {
17183            if !first {
17184                f.write_str(" | ")?;
17185            }
17186            f.write_str("WAIT")?;
17187            remaining &= !Self::WAIT.0;
17188            first = false;
17189        }
17190        if remaining & Self::WITH_AVAILABILITY.0 != 0 {
17191            if !first {
17192                f.write_str(" | ")?;
17193            }
17194            f.write_str("WITH_AVAILABILITY")?;
17195            remaining &= !Self::WITH_AVAILABILITY.0;
17196            first = false;
17197        }
17198        if remaining & Self::PARTIAL.0 != 0 {
17199            if !first {
17200                f.write_str(" | ")?;
17201            }
17202            f.write_str("PARTIAL")?;
17203            remaining &= !Self::PARTIAL.0;
17204            first = false;
17205        }
17206        if remaining & Self::WITH_STATUS.0 != 0 {
17207            if !first {
17208                f.write_str(" | ")?;
17209            }
17210            f.write_str("WITH_STATUS")?;
17211            remaining &= !Self::WITH_STATUS.0;
17212            first = false;
17213        }
17214        if remaining != 0u32 {
17215            if !first {
17216                f.write_str(" | ")?;
17217            }
17218            write!(f, "{:#x}", remaining)?;
17219        } else if first {
17220            f.write_str("(empty)")?;
17221        }
17222        Ok(())
17223    }
17224}
17225///[`VkQueueFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFlagBits.html)
17226#[repr(transparent)]
17227#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
17228#[doc(alias = "VkQueueFlagBits")]
17229pub struct QueueFlagBits(u32);
17230impl QueueFlagBits {
17231    #[inline]
17232    pub const fn empty() -> Self {
17233        Self(0u32)
17234    }
17235    #[inline]
17236    pub const fn from_raw(value: u32) -> Self {
17237        Self(value)
17238    }
17239    #[inline]
17240    pub const fn as_raw(self) -> u32 {
17241        self.0
17242    }
17243    #[inline]
17244    pub const fn is_empty(self) -> bool {
17245        self.0 == 0u32
17246    }
17247    #[inline]
17248    pub const fn contains(self, other: Self) -> bool {
17249        (self.0 & other.0) == other.0
17250    }
17251    ///Bit 0.
17252    pub const GRAPHICS: Self = Self(1u32);
17253    ///Bit 1.
17254    pub const COMPUTE: Self = Self(2u32);
17255    ///Bit 2.
17256    pub const TRANSFER: Self = Self(4u32);
17257    ///Bit 3.
17258    pub const SPARSE_BINDING: Self = Self(8u32);
17259    ///Bit 4.
17260    pub const PROTECTED: Self = Self(16u32);
17261    ///Bit 5.
17262    pub const VIDEO_DECODE: Self = Self(32u32);
17263    ///Bit 6.
17264    pub const VIDEO_ENCODE: Self = Self(64u32);
17265    ///Bit 8.
17266    pub const OPTICAL_FLOW: Self = Self(256u32);
17267    ///Bit 10.
17268    pub const DATA_GRAPH_BIT: Self = Self(1024u32);
17269}
17270impl core::ops::BitOr for QueueFlagBits {
17271    type Output = Self;
17272    #[inline]
17273    fn bitor(self, rhs: Self) -> Self {
17274        Self(self.0 | rhs.0)
17275    }
17276}
17277impl core::ops::BitOrAssign for QueueFlagBits {
17278    #[inline]
17279    fn bitor_assign(&mut self, rhs: Self) {
17280        self.0 |= rhs.0;
17281    }
17282}
17283impl core::ops::BitAnd for QueueFlagBits {
17284    type Output = Self;
17285    #[inline]
17286    fn bitand(self, rhs: Self) -> Self {
17287        Self(self.0 & rhs.0)
17288    }
17289}
17290impl core::ops::BitAndAssign for QueueFlagBits {
17291    #[inline]
17292    fn bitand_assign(&mut self, rhs: Self) {
17293        self.0 &= rhs.0;
17294    }
17295}
17296impl core::ops::BitXor for QueueFlagBits {
17297    type Output = Self;
17298    #[inline]
17299    fn bitxor(self, rhs: Self) -> Self {
17300        Self(self.0 ^ rhs.0)
17301    }
17302}
17303impl core::ops::BitXorAssign for QueueFlagBits {
17304    #[inline]
17305    fn bitxor_assign(&mut self, rhs: Self) {
17306        self.0 ^= rhs.0;
17307    }
17308}
17309impl core::ops::Not for QueueFlagBits {
17310    type Output = Self;
17311    #[inline]
17312    fn not(self) -> Self {
17313        Self(!self.0)
17314    }
17315}
17316impl core::fmt::Debug for QueueFlagBits {
17317    #[allow(unused_mut, unused_variables)]
17318    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17319        let mut first = true;
17320        let mut remaining = self.0;
17321        if remaining & Self::GRAPHICS.0 != 0 {
17322            if !first {
17323                f.write_str(" | ")?;
17324            }
17325            f.write_str("GRAPHICS")?;
17326            remaining &= !Self::GRAPHICS.0;
17327            first = false;
17328        }
17329        if remaining & Self::COMPUTE.0 != 0 {
17330            if !first {
17331                f.write_str(" | ")?;
17332            }
17333            f.write_str("COMPUTE")?;
17334            remaining &= !Self::COMPUTE.0;
17335            first = false;
17336        }
17337        if remaining & Self::TRANSFER.0 != 0 {
17338            if !first {
17339                f.write_str(" | ")?;
17340            }
17341            f.write_str("TRANSFER")?;
17342            remaining &= !Self::TRANSFER.0;
17343            first = false;
17344        }
17345        if remaining & Self::SPARSE_BINDING.0 != 0 {
17346            if !first {
17347                f.write_str(" | ")?;
17348            }
17349            f.write_str("SPARSE_BINDING")?;
17350            remaining &= !Self::SPARSE_BINDING.0;
17351            first = false;
17352        }
17353        if remaining & Self::PROTECTED.0 != 0 {
17354            if !first {
17355                f.write_str(" | ")?;
17356            }
17357            f.write_str("PROTECTED")?;
17358            remaining &= !Self::PROTECTED.0;
17359            first = false;
17360        }
17361        if remaining & Self::VIDEO_DECODE.0 != 0 {
17362            if !first {
17363                f.write_str(" | ")?;
17364            }
17365            f.write_str("VIDEO_DECODE")?;
17366            remaining &= !Self::VIDEO_DECODE.0;
17367            first = false;
17368        }
17369        if remaining & Self::VIDEO_ENCODE.0 != 0 {
17370            if !first {
17371                f.write_str(" | ")?;
17372            }
17373            f.write_str("VIDEO_ENCODE")?;
17374            remaining &= !Self::VIDEO_ENCODE.0;
17375            first = false;
17376        }
17377        if remaining & Self::OPTICAL_FLOW.0 != 0 {
17378            if !first {
17379                f.write_str(" | ")?;
17380            }
17381            f.write_str("OPTICAL_FLOW")?;
17382            remaining &= !Self::OPTICAL_FLOW.0;
17383            first = false;
17384        }
17385        if remaining & Self::DATA_GRAPH_BIT.0 != 0 {
17386            if !first {
17387                f.write_str(" | ")?;
17388            }
17389            f.write_str("DATA_GRAPH_BIT")?;
17390            remaining &= !Self::DATA_GRAPH_BIT.0;
17391            first = false;
17392        }
17393        if remaining != 0u32 {
17394            if !first {
17395                f.write_str(" | ")?;
17396            }
17397            write!(f, "{:#x}", remaining)?;
17398        } else if first {
17399            f.write_str("(empty)")?;
17400        }
17401        Ok(())
17402    }
17403}
17404///[`VkRefreshObjectFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRefreshObjectFlagBitsKHR.html)
17405#[repr(transparent)]
17406#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
17407#[doc(alias = "VkRefreshObjectFlagBitsKHR")]
17408pub struct RefreshObjectFlagBitsKHR(u32);
17409impl RefreshObjectFlagBitsKHR {
17410    #[inline]
17411    pub const fn empty() -> Self {
17412        Self(0u32)
17413    }
17414    #[inline]
17415    pub const fn from_raw(value: u32) -> Self {
17416        Self(value)
17417    }
17418    #[inline]
17419    pub const fn as_raw(self) -> u32 {
17420        self.0
17421    }
17422    #[inline]
17423    pub const fn is_empty(self) -> bool {
17424        self.0 == 0u32
17425    }
17426    #[inline]
17427    pub const fn contains(self, other: Self) -> bool {
17428        (self.0 & other.0) == other.0
17429    }
17430}
17431impl core::ops::BitOr for RefreshObjectFlagBitsKHR {
17432    type Output = Self;
17433    #[inline]
17434    fn bitor(self, rhs: Self) -> Self {
17435        Self(self.0 | rhs.0)
17436    }
17437}
17438impl core::ops::BitOrAssign for RefreshObjectFlagBitsKHR {
17439    #[inline]
17440    fn bitor_assign(&mut self, rhs: Self) {
17441        self.0 |= rhs.0;
17442    }
17443}
17444impl core::ops::BitAnd for RefreshObjectFlagBitsKHR {
17445    type Output = Self;
17446    #[inline]
17447    fn bitand(self, rhs: Self) -> Self {
17448        Self(self.0 & rhs.0)
17449    }
17450}
17451impl core::ops::BitAndAssign for RefreshObjectFlagBitsKHR {
17452    #[inline]
17453    fn bitand_assign(&mut self, rhs: Self) {
17454        self.0 &= rhs.0;
17455    }
17456}
17457impl core::ops::BitXor for RefreshObjectFlagBitsKHR {
17458    type Output = Self;
17459    #[inline]
17460    fn bitxor(self, rhs: Self) -> Self {
17461        Self(self.0 ^ rhs.0)
17462    }
17463}
17464impl core::ops::BitXorAssign for RefreshObjectFlagBitsKHR {
17465    #[inline]
17466    fn bitxor_assign(&mut self, rhs: Self) {
17467        self.0 ^= rhs.0;
17468    }
17469}
17470impl core::ops::Not for RefreshObjectFlagBitsKHR {
17471    type Output = Self;
17472    #[inline]
17473    fn not(self) -> Self {
17474        Self(!self.0)
17475    }
17476}
17477impl core::fmt::Debug for RefreshObjectFlagBitsKHR {
17478    #[allow(unused_mut, unused_variables)]
17479    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17480        let mut first = true;
17481        let mut remaining = self.0;
17482        if remaining != 0u32 {
17483            if !first {
17484                f.write_str(" | ")?;
17485            }
17486            write!(f, "{:#x}", remaining)?;
17487        } else if first {
17488            f.write_str("(empty)")?;
17489        }
17490        Ok(())
17491    }
17492}
17493///[`VkRenderPassCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateFlagBits.html)
17494#[repr(transparent)]
17495#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
17496#[doc(alias = "VkRenderPassCreateFlagBits")]
17497pub struct RenderPassCreateFlagBits(u32);
17498impl RenderPassCreateFlagBits {
17499    #[inline]
17500    pub const fn empty() -> Self {
17501        Self(0u32)
17502    }
17503    #[inline]
17504    pub const fn from_raw(value: u32) -> Self {
17505        Self(value)
17506    }
17507    #[inline]
17508    pub const fn as_raw(self) -> u32 {
17509        self.0
17510    }
17511    #[inline]
17512    pub const fn is_empty(self) -> bool {
17513        self.0 == 0u32
17514    }
17515    #[inline]
17516    pub const fn contains(self, other: Self) -> bool {
17517        (self.0 & other.0) == other.0
17518    }
17519    ///Bit 1.
17520    pub const TRANSFORM_BIT: Self = Self(2u32);
17521    ///Bit 2.
17522    pub const PER_LAYER_FRAGMENT_DENSITY_BIT: Self = Self(4u32);
17523}
17524impl core::ops::BitOr for RenderPassCreateFlagBits {
17525    type Output = Self;
17526    #[inline]
17527    fn bitor(self, rhs: Self) -> Self {
17528        Self(self.0 | rhs.0)
17529    }
17530}
17531impl core::ops::BitOrAssign for RenderPassCreateFlagBits {
17532    #[inline]
17533    fn bitor_assign(&mut self, rhs: Self) {
17534        self.0 |= rhs.0;
17535    }
17536}
17537impl core::ops::BitAnd for RenderPassCreateFlagBits {
17538    type Output = Self;
17539    #[inline]
17540    fn bitand(self, rhs: Self) -> Self {
17541        Self(self.0 & rhs.0)
17542    }
17543}
17544impl core::ops::BitAndAssign for RenderPassCreateFlagBits {
17545    #[inline]
17546    fn bitand_assign(&mut self, rhs: Self) {
17547        self.0 &= rhs.0;
17548    }
17549}
17550impl core::ops::BitXor for RenderPassCreateFlagBits {
17551    type Output = Self;
17552    #[inline]
17553    fn bitxor(self, rhs: Self) -> Self {
17554        Self(self.0 ^ rhs.0)
17555    }
17556}
17557impl core::ops::BitXorAssign for RenderPassCreateFlagBits {
17558    #[inline]
17559    fn bitxor_assign(&mut self, rhs: Self) {
17560        self.0 ^= rhs.0;
17561    }
17562}
17563impl core::ops::Not for RenderPassCreateFlagBits {
17564    type Output = Self;
17565    #[inline]
17566    fn not(self) -> Self {
17567        Self(!self.0)
17568    }
17569}
17570impl core::fmt::Debug for RenderPassCreateFlagBits {
17571    #[allow(unused_mut, unused_variables)]
17572    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17573        let mut first = true;
17574        let mut remaining = self.0;
17575        if remaining & Self::TRANSFORM_BIT.0 != 0 {
17576            if !first {
17577                f.write_str(" | ")?;
17578            }
17579            f.write_str("TRANSFORM_BIT")?;
17580            remaining &= !Self::TRANSFORM_BIT.0;
17581            first = false;
17582        }
17583        if remaining & Self::PER_LAYER_FRAGMENT_DENSITY_BIT.0 != 0 {
17584            if !first {
17585                f.write_str(" | ")?;
17586            }
17587            f.write_str("PER_LAYER_FRAGMENT_DENSITY_BIT")?;
17588            remaining &= !Self::PER_LAYER_FRAGMENT_DENSITY_BIT.0;
17589            first = false;
17590        }
17591        if remaining != 0u32 {
17592            if !first {
17593                f.write_str(" | ")?;
17594            }
17595            write!(f, "{:#x}", remaining)?;
17596        } else if first {
17597            f.write_str("(empty)")?;
17598        }
17599        Ok(())
17600    }
17601}
17602///[`VkRenderingAttachmentFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentFlagBitsKHR.html)
17603#[repr(transparent)]
17604#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
17605#[doc(alias = "VkRenderingAttachmentFlagBitsKHR")]
17606pub struct RenderingAttachmentFlagBitsKHR(u32);
17607impl RenderingAttachmentFlagBitsKHR {
17608    #[inline]
17609    pub const fn empty() -> Self {
17610        Self(0u32)
17611    }
17612    #[inline]
17613    pub const fn from_raw(value: u32) -> Self {
17614        Self(value)
17615    }
17616    #[inline]
17617    pub const fn as_raw(self) -> u32 {
17618        self.0
17619    }
17620    #[inline]
17621    pub const fn is_empty(self) -> bool {
17622        self.0 == 0u32
17623    }
17624    #[inline]
17625    pub const fn contains(self, other: Self) -> bool {
17626        (self.0 & other.0) == other.0
17627    }
17628    ///Bit 0.
17629    pub const INPUT_ATTACHMENT_FEEDBACK: Self = Self(1u32);
17630    ///Bit 1.
17631    pub const RESOLVE_SKIP_TRANSFER_FUNCTION: Self = Self(2u32);
17632    ///Bit 2.
17633    pub const RESOLVE_ENABLE_TRANSFER_FUNCTION: Self = Self(4u32);
17634}
17635impl core::ops::BitOr for RenderingAttachmentFlagBitsKHR {
17636    type Output = Self;
17637    #[inline]
17638    fn bitor(self, rhs: Self) -> Self {
17639        Self(self.0 | rhs.0)
17640    }
17641}
17642impl core::ops::BitOrAssign for RenderingAttachmentFlagBitsKHR {
17643    #[inline]
17644    fn bitor_assign(&mut self, rhs: Self) {
17645        self.0 |= rhs.0;
17646    }
17647}
17648impl core::ops::BitAnd for RenderingAttachmentFlagBitsKHR {
17649    type Output = Self;
17650    #[inline]
17651    fn bitand(self, rhs: Self) -> Self {
17652        Self(self.0 & rhs.0)
17653    }
17654}
17655impl core::ops::BitAndAssign for RenderingAttachmentFlagBitsKHR {
17656    #[inline]
17657    fn bitand_assign(&mut self, rhs: Self) {
17658        self.0 &= rhs.0;
17659    }
17660}
17661impl core::ops::BitXor for RenderingAttachmentFlagBitsKHR {
17662    type Output = Self;
17663    #[inline]
17664    fn bitxor(self, rhs: Self) -> Self {
17665        Self(self.0 ^ rhs.0)
17666    }
17667}
17668impl core::ops::BitXorAssign for RenderingAttachmentFlagBitsKHR {
17669    #[inline]
17670    fn bitxor_assign(&mut self, rhs: Self) {
17671        self.0 ^= rhs.0;
17672    }
17673}
17674impl core::ops::Not for RenderingAttachmentFlagBitsKHR {
17675    type Output = Self;
17676    #[inline]
17677    fn not(self) -> Self {
17678        Self(!self.0)
17679    }
17680}
17681impl core::fmt::Debug for RenderingAttachmentFlagBitsKHR {
17682    #[allow(unused_mut, unused_variables)]
17683    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17684        let mut first = true;
17685        let mut remaining = self.0;
17686        if remaining & Self::INPUT_ATTACHMENT_FEEDBACK.0 != 0 {
17687            if !first {
17688                f.write_str(" | ")?;
17689            }
17690            f.write_str("INPUT_ATTACHMENT_FEEDBACK")?;
17691            remaining &= !Self::INPUT_ATTACHMENT_FEEDBACK.0;
17692            first = false;
17693        }
17694        if remaining & Self::RESOLVE_SKIP_TRANSFER_FUNCTION.0 != 0 {
17695            if !first {
17696                f.write_str(" | ")?;
17697            }
17698            f.write_str("RESOLVE_SKIP_TRANSFER_FUNCTION")?;
17699            remaining &= !Self::RESOLVE_SKIP_TRANSFER_FUNCTION.0;
17700            first = false;
17701        }
17702        if remaining & Self::RESOLVE_ENABLE_TRANSFER_FUNCTION.0 != 0 {
17703            if !first {
17704                f.write_str(" | ")?;
17705            }
17706            f.write_str("RESOLVE_ENABLE_TRANSFER_FUNCTION")?;
17707            remaining &= !Self::RESOLVE_ENABLE_TRANSFER_FUNCTION.0;
17708            first = false;
17709        }
17710        if remaining != 0u32 {
17711            if !first {
17712                f.write_str(" | ")?;
17713            }
17714            write!(f, "{:#x}", remaining)?;
17715        } else if first {
17716            f.write_str("(empty)")?;
17717        }
17718        Ok(())
17719    }
17720}
17721///[`VkRenderingFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFlagBits.html)
17722#[repr(transparent)]
17723#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
17724#[doc(alias = "VkRenderingFlagBits")]
17725pub struct RenderingFlagBits(u32);
17726impl RenderingFlagBits {
17727    #[inline]
17728    pub const fn empty() -> Self {
17729        Self(0u32)
17730    }
17731    #[inline]
17732    pub const fn from_raw(value: u32) -> Self {
17733        Self(value)
17734    }
17735    #[inline]
17736    pub const fn as_raw(self) -> u32 {
17737        self.0
17738    }
17739    #[inline]
17740    pub const fn is_empty(self) -> bool {
17741        self.0 == 0u32
17742    }
17743    #[inline]
17744    pub const fn contains(self, other: Self) -> bool {
17745        (self.0 & other.0) == other.0
17746    }
17747    ///Bit 0.
17748    pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(1u32);
17749    ///Bit 1.
17750    pub const SUSPENDING: Self = Self(2u32);
17751    ///Bit 2.
17752    pub const RESUMING: Self = Self(4u32);
17753    ///Bit 3.
17754    pub const ENABLE_LEGACY_DITHERING: Self = Self(8u32);
17755    ///Bit 5.
17756    pub const PER_LAYER_FRAGMENT_DENSITY_BIT: Self = Self(32u32);
17757    ///Bit 6.
17758    pub const FRAGMENT_REGION: Self = Self(64u32);
17759    ///Bit 7.
17760    pub const CUSTOM_RESOLVE: Self = Self(128u32);
17761    ///Bit 8.
17762    pub const LOCAL_READ_CONCURRENT_ACCESS_CONTROL: Self = Self(256u32);
17763}
17764impl core::ops::BitOr for RenderingFlagBits {
17765    type Output = Self;
17766    #[inline]
17767    fn bitor(self, rhs: Self) -> Self {
17768        Self(self.0 | rhs.0)
17769    }
17770}
17771impl core::ops::BitOrAssign for RenderingFlagBits {
17772    #[inline]
17773    fn bitor_assign(&mut self, rhs: Self) {
17774        self.0 |= rhs.0;
17775    }
17776}
17777impl core::ops::BitAnd for RenderingFlagBits {
17778    type Output = Self;
17779    #[inline]
17780    fn bitand(self, rhs: Self) -> Self {
17781        Self(self.0 & rhs.0)
17782    }
17783}
17784impl core::ops::BitAndAssign for RenderingFlagBits {
17785    #[inline]
17786    fn bitand_assign(&mut self, rhs: Self) {
17787        self.0 &= rhs.0;
17788    }
17789}
17790impl core::ops::BitXor for RenderingFlagBits {
17791    type Output = Self;
17792    #[inline]
17793    fn bitxor(self, rhs: Self) -> Self {
17794        Self(self.0 ^ rhs.0)
17795    }
17796}
17797impl core::ops::BitXorAssign for RenderingFlagBits {
17798    #[inline]
17799    fn bitxor_assign(&mut self, rhs: Self) {
17800        self.0 ^= rhs.0;
17801    }
17802}
17803impl core::ops::Not for RenderingFlagBits {
17804    type Output = Self;
17805    #[inline]
17806    fn not(self) -> Self {
17807        Self(!self.0)
17808    }
17809}
17810impl core::fmt::Debug for RenderingFlagBits {
17811    #[allow(unused_mut, unused_variables)]
17812    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17813        let mut first = true;
17814        let mut remaining = self.0;
17815        if remaining & Self::CONTENTS_SECONDARY_COMMAND_BUFFERS.0 != 0 {
17816            if !first {
17817                f.write_str(" | ")?;
17818            }
17819            f.write_str("CONTENTS_SECONDARY_COMMAND_BUFFERS")?;
17820            remaining &= !Self::CONTENTS_SECONDARY_COMMAND_BUFFERS.0;
17821            first = false;
17822        }
17823        if remaining & Self::SUSPENDING.0 != 0 {
17824            if !first {
17825                f.write_str(" | ")?;
17826            }
17827            f.write_str("SUSPENDING")?;
17828            remaining &= !Self::SUSPENDING.0;
17829            first = false;
17830        }
17831        if remaining & Self::RESUMING.0 != 0 {
17832            if !first {
17833                f.write_str(" | ")?;
17834            }
17835            f.write_str("RESUMING")?;
17836            remaining &= !Self::RESUMING.0;
17837            first = false;
17838        }
17839        if remaining & Self::ENABLE_LEGACY_DITHERING.0 != 0 {
17840            if !first {
17841                f.write_str(" | ")?;
17842            }
17843            f.write_str("ENABLE_LEGACY_DITHERING")?;
17844            remaining &= !Self::ENABLE_LEGACY_DITHERING.0;
17845            first = false;
17846        }
17847        if remaining & Self::PER_LAYER_FRAGMENT_DENSITY_BIT.0 != 0 {
17848            if !first {
17849                f.write_str(" | ")?;
17850            }
17851            f.write_str("PER_LAYER_FRAGMENT_DENSITY_BIT")?;
17852            remaining &= !Self::PER_LAYER_FRAGMENT_DENSITY_BIT.0;
17853            first = false;
17854        }
17855        if remaining & Self::FRAGMENT_REGION.0 != 0 {
17856            if !first {
17857                f.write_str(" | ")?;
17858            }
17859            f.write_str("FRAGMENT_REGION")?;
17860            remaining &= !Self::FRAGMENT_REGION.0;
17861            first = false;
17862        }
17863        if remaining & Self::CUSTOM_RESOLVE.0 != 0 {
17864            if !first {
17865                f.write_str(" | ")?;
17866            }
17867            f.write_str("CUSTOM_RESOLVE")?;
17868            remaining &= !Self::CUSTOM_RESOLVE.0;
17869            first = false;
17870        }
17871        if remaining & Self::LOCAL_READ_CONCURRENT_ACCESS_CONTROL.0 != 0 {
17872            if !first {
17873                f.write_str(" | ")?;
17874            }
17875            f.write_str("LOCAL_READ_CONCURRENT_ACCESS_CONTROL")?;
17876            remaining &= !Self::LOCAL_READ_CONCURRENT_ACCESS_CONTROL.0;
17877            first = false;
17878        }
17879        if remaining != 0u32 {
17880            if !first {
17881                f.write_str(" | ")?;
17882            }
17883            write!(f, "{:#x}", remaining)?;
17884        } else if first {
17885            f.write_str("(empty)")?;
17886        }
17887        Ok(())
17888    }
17889}
17890///[`VkResolveImageFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageFlagBitsKHR.html)
17891#[repr(transparent)]
17892#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
17893#[doc(alias = "VkResolveImageFlagBitsKHR")]
17894pub struct ResolveImageFlagBitsKHR(u32);
17895impl ResolveImageFlagBitsKHR {
17896    #[inline]
17897    pub const fn empty() -> Self {
17898        Self(0u32)
17899    }
17900    #[inline]
17901    pub const fn from_raw(value: u32) -> Self {
17902        Self(value)
17903    }
17904    #[inline]
17905    pub const fn as_raw(self) -> u32 {
17906        self.0
17907    }
17908    #[inline]
17909    pub const fn is_empty(self) -> bool {
17910        self.0 == 0u32
17911    }
17912    #[inline]
17913    pub const fn contains(self, other: Self) -> bool {
17914        (self.0 & other.0) == other.0
17915    }
17916    ///Bit 0.
17917    pub const SKIP_TRANSFER_FUNCTION: Self = Self(1u32);
17918    ///Bit 1.
17919    pub const ENABLE_TRANSFER_FUNCTION: Self = Self(2u32);
17920}
17921impl core::ops::BitOr for ResolveImageFlagBitsKHR {
17922    type Output = Self;
17923    #[inline]
17924    fn bitor(self, rhs: Self) -> Self {
17925        Self(self.0 | rhs.0)
17926    }
17927}
17928impl core::ops::BitOrAssign for ResolveImageFlagBitsKHR {
17929    #[inline]
17930    fn bitor_assign(&mut self, rhs: Self) {
17931        self.0 |= rhs.0;
17932    }
17933}
17934impl core::ops::BitAnd for ResolveImageFlagBitsKHR {
17935    type Output = Self;
17936    #[inline]
17937    fn bitand(self, rhs: Self) -> Self {
17938        Self(self.0 & rhs.0)
17939    }
17940}
17941impl core::ops::BitAndAssign for ResolveImageFlagBitsKHR {
17942    #[inline]
17943    fn bitand_assign(&mut self, rhs: Self) {
17944        self.0 &= rhs.0;
17945    }
17946}
17947impl core::ops::BitXor for ResolveImageFlagBitsKHR {
17948    type Output = Self;
17949    #[inline]
17950    fn bitxor(self, rhs: Self) -> Self {
17951        Self(self.0 ^ rhs.0)
17952    }
17953}
17954impl core::ops::BitXorAssign for ResolveImageFlagBitsKHR {
17955    #[inline]
17956    fn bitxor_assign(&mut self, rhs: Self) {
17957        self.0 ^= rhs.0;
17958    }
17959}
17960impl core::ops::Not for ResolveImageFlagBitsKHR {
17961    type Output = Self;
17962    #[inline]
17963    fn not(self) -> Self {
17964        Self(!self.0)
17965    }
17966}
17967impl core::fmt::Debug for ResolveImageFlagBitsKHR {
17968    #[allow(unused_mut, unused_variables)]
17969    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
17970        let mut first = true;
17971        let mut remaining = self.0;
17972        if remaining & Self::SKIP_TRANSFER_FUNCTION.0 != 0 {
17973            if !first {
17974                f.write_str(" | ")?;
17975            }
17976            f.write_str("SKIP_TRANSFER_FUNCTION")?;
17977            remaining &= !Self::SKIP_TRANSFER_FUNCTION.0;
17978            first = false;
17979        }
17980        if remaining & Self::ENABLE_TRANSFER_FUNCTION.0 != 0 {
17981            if !first {
17982                f.write_str(" | ")?;
17983            }
17984            f.write_str("ENABLE_TRANSFER_FUNCTION")?;
17985            remaining &= !Self::ENABLE_TRANSFER_FUNCTION.0;
17986            first = false;
17987        }
17988        if remaining != 0u32 {
17989            if !first {
17990                f.write_str(" | ")?;
17991            }
17992            write!(f, "{:#x}", remaining)?;
17993        } else if first {
17994            f.write_str("(empty)")?;
17995        }
17996        Ok(())
17997    }
17998}
17999///[`VkResolveModeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveModeFlagBits.html)
18000#[repr(transparent)]
18001#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
18002#[doc(alias = "VkResolveModeFlagBits")]
18003pub struct ResolveModeFlagBits(u32);
18004impl ResolveModeFlagBits {
18005    #[inline]
18006    pub const fn empty() -> Self {
18007        Self(0u32)
18008    }
18009    #[inline]
18010    pub const fn from_raw(value: u32) -> Self {
18011        Self(value)
18012    }
18013    #[inline]
18014    pub const fn as_raw(self) -> u32 {
18015        self.0
18016    }
18017    #[inline]
18018    pub const fn is_empty(self) -> bool {
18019        self.0 == 0u32
18020    }
18021    #[inline]
18022    pub const fn contains(self, other: Self) -> bool {
18023        (self.0 & other.0) == other.0
18024    }
18025    pub const NONE: Self = Self(0u32);
18026    ///Bit 0.
18027    pub const SAMPLE_ZERO: Self = Self(1u32);
18028    ///Bit 1.
18029    pub const AVERAGE: Self = Self(2u32);
18030    ///Bit 2.
18031    pub const MIN: Self = Self(4u32);
18032    ///Bit 3.
18033    pub const MAX: Self = Self(8u32);
18034    ///Bit 4.
18035    pub const EXTERNAL_FORMAT_DOWNSAMPLE_BIT: Self = Self(16u32);
18036    pub const EXTERNAL_FORMAT_DOWNSAMPLE: Self = Self::EXTERNAL_FORMAT_DOWNSAMPLE_BIT;
18037    ///Bit 5.
18038    pub const CUSTOM: Self = Self(32u32);
18039}
18040impl core::ops::BitOr for ResolveModeFlagBits {
18041    type Output = Self;
18042    #[inline]
18043    fn bitor(self, rhs: Self) -> Self {
18044        Self(self.0 | rhs.0)
18045    }
18046}
18047impl core::ops::BitOrAssign for ResolveModeFlagBits {
18048    #[inline]
18049    fn bitor_assign(&mut self, rhs: Self) {
18050        self.0 |= rhs.0;
18051    }
18052}
18053impl core::ops::BitAnd for ResolveModeFlagBits {
18054    type Output = Self;
18055    #[inline]
18056    fn bitand(self, rhs: Self) -> Self {
18057        Self(self.0 & rhs.0)
18058    }
18059}
18060impl core::ops::BitAndAssign for ResolveModeFlagBits {
18061    #[inline]
18062    fn bitand_assign(&mut self, rhs: Self) {
18063        self.0 &= rhs.0;
18064    }
18065}
18066impl core::ops::BitXor for ResolveModeFlagBits {
18067    type Output = Self;
18068    #[inline]
18069    fn bitxor(self, rhs: Self) -> Self {
18070        Self(self.0 ^ rhs.0)
18071    }
18072}
18073impl core::ops::BitXorAssign for ResolveModeFlagBits {
18074    #[inline]
18075    fn bitxor_assign(&mut self, rhs: Self) {
18076        self.0 ^= rhs.0;
18077    }
18078}
18079impl core::ops::Not for ResolveModeFlagBits {
18080    type Output = Self;
18081    #[inline]
18082    fn not(self) -> Self {
18083        Self(!self.0)
18084    }
18085}
18086impl core::fmt::Debug for ResolveModeFlagBits {
18087    #[allow(unused_mut, unused_variables)]
18088    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18089        let mut first = true;
18090        let mut remaining = self.0;
18091        if remaining & Self::SAMPLE_ZERO.0 != 0 {
18092            if !first {
18093                f.write_str(" | ")?;
18094            }
18095            f.write_str("SAMPLE_ZERO")?;
18096            remaining &= !Self::SAMPLE_ZERO.0;
18097            first = false;
18098        }
18099        if remaining & Self::AVERAGE.0 != 0 {
18100            if !first {
18101                f.write_str(" | ")?;
18102            }
18103            f.write_str("AVERAGE")?;
18104            remaining &= !Self::AVERAGE.0;
18105            first = false;
18106        }
18107        if remaining & Self::MIN.0 != 0 {
18108            if !first {
18109                f.write_str(" | ")?;
18110            }
18111            f.write_str("MIN")?;
18112            remaining &= !Self::MIN.0;
18113            first = false;
18114        }
18115        if remaining & Self::MAX.0 != 0 {
18116            if !first {
18117                f.write_str(" | ")?;
18118            }
18119            f.write_str("MAX")?;
18120            remaining &= !Self::MAX.0;
18121            first = false;
18122        }
18123        if remaining & Self::EXTERNAL_FORMAT_DOWNSAMPLE_BIT.0 != 0 {
18124            if !first {
18125                f.write_str(" | ")?;
18126            }
18127            f.write_str("EXTERNAL_FORMAT_DOWNSAMPLE_BIT")?;
18128            remaining &= !Self::EXTERNAL_FORMAT_DOWNSAMPLE_BIT.0;
18129            first = false;
18130        }
18131        if remaining & Self::CUSTOM.0 != 0 {
18132            if !first {
18133                f.write_str(" | ")?;
18134            }
18135            f.write_str("CUSTOM")?;
18136            remaining &= !Self::CUSTOM.0;
18137            first = false;
18138        }
18139        if remaining != 0u32 {
18140            if !first {
18141                f.write_str(" | ")?;
18142            }
18143            write!(f, "{:#x}", remaining)?;
18144        } else if first {
18145            f.write_str("(empty)")?;
18146        }
18147        Ok(())
18148    }
18149}
18150///[`VkSampleCountFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleCountFlagBits.html)
18151#[repr(transparent)]
18152#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
18153#[doc(alias = "VkSampleCountFlagBits")]
18154pub struct SampleCountFlagBits(u32);
18155impl SampleCountFlagBits {
18156    #[inline]
18157    pub const fn empty() -> Self {
18158        Self(0u32)
18159    }
18160    #[inline]
18161    pub const fn from_raw(value: u32) -> Self {
18162        Self(value)
18163    }
18164    #[inline]
18165    pub const fn as_raw(self) -> u32 {
18166        self.0
18167    }
18168    #[inline]
18169    pub const fn is_empty(self) -> bool {
18170        self.0 == 0u32
18171    }
18172    #[inline]
18173    pub const fn contains(self, other: Self) -> bool {
18174        (self.0 & other.0) == other.0
18175    }
18176    ///Bit 0.
18177    pub const _1: Self = Self(1u32);
18178    ///Bit 1.
18179    pub const _2: Self = Self(2u32);
18180    ///Bit 2.
18181    pub const _4: Self = Self(4u32);
18182    ///Bit 3.
18183    pub const _8: Self = Self(8u32);
18184    ///Bit 4.
18185    pub const _16: Self = Self(16u32);
18186    ///Bit 5.
18187    pub const _32: Self = Self(32u32);
18188    ///Bit 6.
18189    pub const _64: Self = Self(64u32);
18190}
18191impl core::ops::BitOr for SampleCountFlagBits {
18192    type Output = Self;
18193    #[inline]
18194    fn bitor(self, rhs: Self) -> Self {
18195        Self(self.0 | rhs.0)
18196    }
18197}
18198impl core::ops::BitOrAssign for SampleCountFlagBits {
18199    #[inline]
18200    fn bitor_assign(&mut self, rhs: Self) {
18201        self.0 |= rhs.0;
18202    }
18203}
18204impl core::ops::BitAnd for SampleCountFlagBits {
18205    type Output = Self;
18206    #[inline]
18207    fn bitand(self, rhs: Self) -> Self {
18208        Self(self.0 & rhs.0)
18209    }
18210}
18211impl core::ops::BitAndAssign for SampleCountFlagBits {
18212    #[inline]
18213    fn bitand_assign(&mut self, rhs: Self) {
18214        self.0 &= rhs.0;
18215    }
18216}
18217impl core::ops::BitXor for SampleCountFlagBits {
18218    type Output = Self;
18219    #[inline]
18220    fn bitxor(self, rhs: Self) -> Self {
18221        Self(self.0 ^ rhs.0)
18222    }
18223}
18224impl core::ops::BitXorAssign for SampleCountFlagBits {
18225    #[inline]
18226    fn bitxor_assign(&mut self, rhs: Self) {
18227        self.0 ^= rhs.0;
18228    }
18229}
18230impl core::ops::Not for SampleCountFlagBits {
18231    type Output = Self;
18232    #[inline]
18233    fn not(self) -> Self {
18234        Self(!self.0)
18235    }
18236}
18237impl core::fmt::Debug for SampleCountFlagBits {
18238    #[allow(unused_mut, unused_variables)]
18239    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18240        let mut first = true;
18241        let mut remaining = self.0;
18242        if remaining & Self::_1.0 != 0 {
18243            if !first {
18244                f.write_str(" | ")?;
18245            }
18246            f.write_str("_1")?;
18247            remaining &= !Self::_1.0;
18248            first = false;
18249        }
18250        if remaining & Self::_2.0 != 0 {
18251            if !first {
18252                f.write_str(" | ")?;
18253            }
18254            f.write_str("_2")?;
18255            remaining &= !Self::_2.0;
18256            first = false;
18257        }
18258        if remaining & Self::_4.0 != 0 {
18259            if !first {
18260                f.write_str(" | ")?;
18261            }
18262            f.write_str("_4")?;
18263            remaining &= !Self::_4.0;
18264            first = false;
18265        }
18266        if remaining & Self::_8.0 != 0 {
18267            if !first {
18268                f.write_str(" | ")?;
18269            }
18270            f.write_str("_8")?;
18271            remaining &= !Self::_8.0;
18272            first = false;
18273        }
18274        if remaining & Self::_16.0 != 0 {
18275            if !first {
18276                f.write_str(" | ")?;
18277            }
18278            f.write_str("_16")?;
18279            remaining &= !Self::_16.0;
18280            first = false;
18281        }
18282        if remaining & Self::_32.0 != 0 {
18283            if !first {
18284                f.write_str(" | ")?;
18285            }
18286            f.write_str("_32")?;
18287            remaining &= !Self::_32.0;
18288            first = false;
18289        }
18290        if remaining & Self::_64.0 != 0 {
18291            if !first {
18292                f.write_str(" | ")?;
18293            }
18294            f.write_str("_64")?;
18295            remaining &= !Self::_64.0;
18296            first = false;
18297        }
18298        if remaining != 0u32 {
18299            if !first {
18300                f.write_str(" | ")?;
18301            }
18302            write!(f, "{:#x}", remaining)?;
18303        } else if first {
18304            f.write_str("(empty)")?;
18305        }
18306        Ok(())
18307    }
18308}
18309///[`VkSamplerCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateFlagBits.html)
18310#[repr(transparent)]
18311#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
18312#[doc(alias = "VkSamplerCreateFlagBits")]
18313pub struct SamplerCreateFlagBits(u32);
18314impl SamplerCreateFlagBits {
18315    #[inline]
18316    pub const fn empty() -> Self {
18317        Self(0u32)
18318    }
18319    #[inline]
18320    pub const fn from_raw(value: u32) -> Self {
18321        Self(value)
18322    }
18323    #[inline]
18324    pub const fn as_raw(self) -> u32 {
18325        self.0
18326    }
18327    #[inline]
18328    pub const fn is_empty(self) -> bool {
18329        self.0 == 0u32
18330    }
18331    #[inline]
18332    pub const fn contains(self, other: Self) -> bool {
18333        (self.0 & other.0) == other.0
18334    }
18335    ///Bit 0.
18336    pub const SUBSAMPLED: Self = Self(1u32);
18337    ///Bit 1.
18338    pub const SUBSAMPLED_COARSE_RECONSTRUCTION: Self = Self(2u32);
18339    ///Bit 3.
18340    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY: Self = Self(8u32);
18341    ///Bit 2.
18342    pub const NON_SEAMLESS_CUBE_MAP: Self = Self(4u32);
18343    ///Bit 4.
18344    pub const IMAGE_PROCESSING_BIT: Self = Self(16u32);
18345}
18346impl core::ops::BitOr for SamplerCreateFlagBits {
18347    type Output = Self;
18348    #[inline]
18349    fn bitor(self, rhs: Self) -> Self {
18350        Self(self.0 | rhs.0)
18351    }
18352}
18353impl core::ops::BitOrAssign for SamplerCreateFlagBits {
18354    #[inline]
18355    fn bitor_assign(&mut self, rhs: Self) {
18356        self.0 |= rhs.0;
18357    }
18358}
18359impl core::ops::BitAnd for SamplerCreateFlagBits {
18360    type Output = Self;
18361    #[inline]
18362    fn bitand(self, rhs: Self) -> Self {
18363        Self(self.0 & rhs.0)
18364    }
18365}
18366impl core::ops::BitAndAssign for SamplerCreateFlagBits {
18367    #[inline]
18368    fn bitand_assign(&mut self, rhs: Self) {
18369        self.0 &= rhs.0;
18370    }
18371}
18372impl core::ops::BitXor for SamplerCreateFlagBits {
18373    type Output = Self;
18374    #[inline]
18375    fn bitxor(self, rhs: Self) -> Self {
18376        Self(self.0 ^ rhs.0)
18377    }
18378}
18379impl core::ops::BitXorAssign for SamplerCreateFlagBits {
18380    #[inline]
18381    fn bitxor_assign(&mut self, rhs: Self) {
18382        self.0 ^= rhs.0;
18383    }
18384}
18385impl core::ops::Not for SamplerCreateFlagBits {
18386    type Output = Self;
18387    #[inline]
18388    fn not(self) -> Self {
18389        Self(!self.0)
18390    }
18391}
18392impl core::fmt::Debug for SamplerCreateFlagBits {
18393    #[allow(unused_mut, unused_variables)]
18394    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18395        let mut first = true;
18396        let mut remaining = self.0;
18397        if remaining & Self::SUBSAMPLED.0 != 0 {
18398            if !first {
18399                f.write_str(" | ")?;
18400            }
18401            f.write_str("SUBSAMPLED")?;
18402            remaining &= !Self::SUBSAMPLED.0;
18403            first = false;
18404        }
18405        if remaining & Self::SUBSAMPLED_COARSE_RECONSTRUCTION.0 != 0 {
18406            if !first {
18407                f.write_str(" | ")?;
18408            }
18409            f.write_str("SUBSAMPLED_COARSE_RECONSTRUCTION")?;
18410            remaining &= !Self::SUBSAMPLED_COARSE_RECONSTRUCTION.0;
18411            first = false;
18412        }
18413        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0 != 0 {
18414            if !first {
18415                f.write_str(" | ")?;
18416            }
18417            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY")?;
18418            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY.0;
18419            first = false;
18420        }
18421        if remaining & Self::NON_SEAMLESS_CUBE_MAP.0 != 0 {
18422            if !first {
18423                f.write_str(" | ")?;
18424            }
18425            f.write_str("NON_SEAMLESS_CUBE_MAP")?;
18426            remaining &= !Self::NON_SEAMLESS_CUBE_MAP.0;
18427            first = false;
18428        }
18429        if remaining & Self::IMAGE_PROCESSING_BIT.0 != 0 {
18430            if !first {
18431                f.write_str(" | ")?;
18432            }
18433            f.write_str("IMAGE_PROCESSING_BIT")?;
18434            remaining &= !Self::IMAGE_PROCESSING_BIT.0;
18435            first = false;
18436        }
18437        if remaining != 0u32 {
18438            if !first {
18439                f.write_str(" | ")?;
18440            }
18441            write!(f, "{:#x}", remaining)?;
18442        } else if first {
18443            f.write_str("(empty)")?;
18444        }
18445        Ok(())
18446    }
18447}
18448///[`VkSemaphoreCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreCreateFlagBits.html)
18449#[repr(transparent)]
18450#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
18451#[doc(alias = "VkSemaphoreCreateFlagBits")]
18452pub struct SemaphoreCreateFlagBits(u32);
18453impl SemaphoreCreateFlagBits {
18454    #[inline]
18455    pub const fn empty() -> Self {
18456        Self(0u32)
18457    }
18458    #[inline]
18459    pub const fn from_raw(value: u32) -> Self {
18460        Self(value)
18461    }
18462    #[inline]
18463    pub const fn as_raw(self) -> u32 {
18464        self.0
18465    }
18466    #[inline]
18467    pub const fn is_empty(self) -> bool {
18468        self.0 == 0u32
18469    }
18470    #[inline]
18471    pub const fn contains(self, other: Self) -> bool {
18472        (self.0 & other.0) == other.0
18473    }
18474}
18475impl core::ops::BitOr for SemaphoreCreateFlagBits {
18476    type Output = Self;
18477    #[inline]
18478    fn bitor(self, rhs: Self) -> Self {
18479        Self(self.0 | rhs.0)
18480    }
18481}
18482impl core::ops::BitOrAssign for SemaphoreCreateFlagBits {
18483    #[inline]
18484    fn bitor_assign(&mut self, rhs: Self) {
18485        self.0 |= rhs.0;
18486    }
18487}
18488impl core::ops::BitAnd for SemaphoreCreateFlagBits {
18489    type Output = Self;
18490    #[inline]
18491    fn bitand(self, rhs: Self) -> Self {
18492        Self(self.0 & rhs.0)
18493    }
18494}
18495impl core::ops::BitAndAssign for SemaphoreCreateFlagBits {
18496    #[inline]
18497    fn bitand_assign(&mut self, rhs: Self) {
18498        self.0 &= rhs.0;
18499    }
18500}
18501impl core::ops::BitXor for SemaphoreCreateFlagBits {
18502    type Output = Self;
18503    #[inline]
18504    fn bitxor(self, rhs: Self) -> Self {
18505        Self(self.0 ^ rhs.0)
18506    }
18507}
18508impl core::ops::BitXorAssign for SemaphoreCreateFlagBits {
18509    #[inline]
18510    fn bitxor_assign(&mut self, rhs: Self) {
18511        self.0 ^= rhs.0;
18512    }
18513}
18514impl core::ops::Not for SemaphoreCreateFlagBits {
18515    type Output = Self;
18516    #[inline]
18517    fn not(self) -> Self {
18518        Self(!self.0)
18519    }
18520}
18521impl core::fmt::Debug for SemaphoreCreateFlagBits {
18522    #[allow(unused_mut, unused_variables)]
18523    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18524        let mut first = true;
18525        let mut remaining = self.0;
18526        if remaining != 0u32 {
18527            if !first {
18528                f.write_str(" | ")?;
18529            }
18530            write!(f, "{:#x}", remaining)?;
18531        } else if first {
18532            f.write_str("(empty)")?;
18533        }
18534        Ok(())
18535    }
18536}
18537///[`VkSemaphoreImportFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreImportFlagBits.html)
18538#[repr(transparent)]
18539#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
18540#[doc(alias = "VkSemaphoreImportFlagBits")]
18541pub struct SemaphoreImportFlagBits(u32);
18542impl SemaphoreImportFlagBits {
18543    #[inline]
18544    pub const fn empty() -> Self {
18545        Self(0u32)
18546    }
18547    #[inline]
18548    pub const fn from_raw(value: u32) -> Self {
18549        Self(value)
18550    }
18551    #[inline]
18552    pub const fn as_raw(self) -> u32 {
18553        self.0
18554    }
18555    #[inline]
18556    pub const fn is_empty(self) -> bool {
18557        self.0 == 0u32
18558    }
18559    #[inline]
18560    pub const fn contains(self, other: Self) -> bool {
18561        (self.0 & other.0) == other.0
18562    }
18563    ///Bit 0.
18564    pub const TEMPORARY: Self = Self(1u32);
18565}
18566impl core::ops::BitOr for SemaphoreImportFlagBits {
18567    type Output = Self;
18568    #[inline]
18569    fn bitor(self, rhs: Self) -> Self {
18570        Self(self.0 | rhs.0)
18571    }
18572}
18573impl core::ops::BitOrAssign for SemaphoreImportFlagBits {
18574    #[inline]
18575    fn bitor_assign(&mut self, rhs: Self) {
18576        self.0 |= rhs.0;
18577    }
18578}
18579impl core::ops::BitAnd for SemaphoreImportFlagBits {
18580    type Output = Self;
18581    #[inline]
18582    fn bitand(self, rhs: Self) -> Self {
18583        Self(self.0 & rhs.0)
18584    }
18585}
18586impl core::ops::BitAndAssign for SemaphoreImportFlagBits {
18587    #[inline]
18588    fn bitand_assign(&mut self, rhs: Self) {
18589        self.0 &= rhs.0;
18590    }
18591}
18592impl core::ops::BitXor for SemaphoreImportFlagBits {
18593    type Output = Self;
18594    #[inline]
18595    fn bitxor(self, rhs: Self) -> Self {
18596        Self(self.0 ^ rhs.0)
18597    }
18598}
18599impl core::ops::BitXorAssign for SemaphoreImportFlagBits {
18600    #[inline]
18601    fn bitxor_assign(&mut self, rhs: Self) {
18602        self.0 ^= rhs.0;
18603    }
18604}
18605impl core::ops::Not for SemaphoreImportFlagBits {
18606    type Output = Self;
18607    #[inline]
18608    fn not(self) -> Self {
18609        Self(!self.0)
18610    }
18611}
18612impl core::fmt::Debug for SemaphoreImportFlagBits {
18613    #[allow(unused_mut, unused_variables)]
18614    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18615        let mut first = true;
18616        let mut remaining = self.0;
18617        if remaining & Self::TEMPORARY.0 != 0 {
18618            if !first {
18619                f.write_str(" | ")?;
18620            }
18621            f.write_str("TEMPORARY")?;
18622            remaining &= !Self::TEMPORARY.0;
18623            first = false;
18624        }
18625        if remaining != 0u32 {
18626            if !first {
18627                f.write_str(" | ")?;
18628            }
18629            write!(f, "{:#x}", remaining)?;
18630        } else if first {
18631            f.write_str("(empty)")?;
18632        }
18633        Ok(())
18634    }
18635}
18636///[`VkSemaphoreWaitFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitFlagBits.html)
18637#[repr(transparent)]
18638#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
18639#[doc(alias = "VkSemaphoreWaitFlagBits")]
18640pub struct SemaphoreWaitFlagBits(u32);
18641impl SemaphoreWaitFlagBits {
18642    #[inline]
18643    pub const fn empty() -> Self {
18644        Self(0u32)
18645    }
18646    #[inline]
18647    pub const fn from_raw(value: u32) -> Self {
18648        Self(value)
18649    }
18650    #[inline]
18651    pub const fn as_raw(self) -> u32 {
18652        self.0
18653    }
18654    #[inline]
18655    pub const fn is_empty(self) -> bool {
18656        self.0 == 0u32
18657    }
18658    #[inline]
18659    pub const fn contains(self, other: Self) -> bool {
18660        (self.0 & other.0) == other.0
18661    }
18662    ///Bit 0.
18663    pub const ANY: Self = Self(1u32);
18664}
18665impl core::ops::BitOr for SemaphoreWaitFlagBits {
18666    type Output = Self;
18667    #[inline]
18668    fn bitor(self, rhs: Self) -> Self {
18669        Self(self.0 | rhs.0)
18670    }
18671}
18672impl core::ops::BitOrAssign for SemaphoreWaitFlagBits {
18673    #[inline]
18674    fn bitor_assign(&mut self, rhs: Self) {
18675        self.0 |= rhs.0;
18676    }
18677}
18678impl core::ops::BitAnd for SemaphoreWaitFlagBits {
18679    type Output = Self;
18680    #[inline]
18681    fn bitand(self, rhs: Self) -> Self {
18682        Self(self.0 & rhs.0)
18683    }
18684}
18685impl core::ops::BitAndAssign for SemaphoreWaitFlagBits {
18686    #[inline]
18687    fn bitand_assign(&mut self, rhs: Self) {
18688        self.0 &= rhs.0;
18689    }
18690}
18691impl core::ops::BitXor for SemaphoreWaitFlagBits {
18692    type Output = Self;
18693    #[inline]
18694    fn bitxor(self, rhs: Self) -> Self {
18695        Self(self.0 ^ rhs.0)
18696    }
18697}
18698impl core::ops::BitXorAssign for SemaphoreWaitFlagBits {
18699    #[inline]
18700    fn bitxor_assign(&mut self, rhs: Self) {
18701        self.0 ^= rhs.0;
18702    }
18703}
18704impl core::ops::Not for SemaphoreWaitFlagBits {
18705    type Output = Self;
18706    #[inline]
18707    fn not(self) -> Self {
18708        Self(!self.0)
18709    }
18710}
18711impl core::fmt::Debug for SemaphoreWaitFlagBits {
18712    #[allow(unused_mut, unused_variables)]
18713    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18714        let mut first = true;
18715        let mut remaining = self.0;
18716        if remaining & Self::ANY.0 != 0 {
18717            if !first {
18718                f.write_str(" | ")?;
18719            }
18720            f.write_str("ANY")?;
18721            remaining &= !Self::ANY.0;
18722            first = false;
18723        }
18724        if remaining != 0u32 {
18725            if !first {
18726                f.write_str(" | ")?;
18727            }
18728            write!(f, "{:#x}", remaining)?;
18729        } else if first {
18730            f.write_str("(empty)")?;
18731        }
18732        Ok(())
18733    }
18734}
18735///[`VkShaderCorePropertiesFlagBitsAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCorePropertiesFlagBitsAMD.html)
18736#[repr(transparent)]
18737#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
18738#[doc(alias = "VkShaderCorePropertiesFlagBitsAMD")]
18739pub struct ShaderCorePropertiesFlagBitsAMD(u32);
18740impl ShaderCorePropertiesFlagBitsAMD {
18741    #[inline]
18742    pub const fn empty() -> Self {
18743        Self(0u32)
18744    }
18745    #[inline]
18746    pub const fn from_raw(value: u32) -> Self {
18747        Self(value)
18748    }
18749    #[inline]
18750    pub const fn as_raw(self) -> u32 {
18751        self.0
18752    }
18753    #[inline]
18754    pub const fn is_empty(self) -> bool {
18755        self.0 == 0u32
18756    }
18757    #[inline]
18758    pub const fn contains(self, other: Self) -> bool {
18759        (self.0 & other.0) == other.0
18760    }
18761}
18762impl core::ops::BitOr for ShaderCorePropertiesFlagBitsAMD {
18763    type Output = Self;
18764    #[inline]
18765    fn bitor(self, rhs: Self) -> Self {
18766        Self(self.0 | rhs.0)
18767    }
18768}
18769impl core::ops::BitOrAssign for ShaderCorePropertiesFlagBitsAMD {
18770    #[inline]
18771    fn bitor_assign(&mut self, rhs: Self) {
18772        self.0 |= rhs.0;
18773    }
18774}
18775impl core::ops::BitAnd for ShaderCorePropertiesFlagBitsAMD {
18776    type Output = Self;
18777    #[inline]
18778    fn bitand(self, rhs: Self) -> Self {
18779        Self(self.0 & rhs.0)
18780    }
18781}
18782impl core::ops::BitAndAssign for ShaderCorePropertiesFlagBitsAMD {
18783    #[inline]
18784    fn bitand_assign(&mut self, rhs: Self) {
18785        self.0 &= rhs.0;
18786    }
18787}
18788impl core::ops::BitXor for ShaderCorePropertiesFlagBitsAMD {
18789    type Output = Self;
18790    #[inline]
18791    fn bitxor(self, rhs: Self) -> Self {
18792        Self(self.0 ^ rhs.0)
18793    }
18794}
18795impl core::ops::BitXorAssign for ShaderCorePropertiesFlagBitsAMD {
18796    #[inline]
18797    fn bitxor_assign(&mut self, rhs: Self) {
18798        self.0 ^= rhs.0;
18799    }
18800}
18801impl core::ops::Not for ShaderCorePropertiesFlagBitsAMD {
18802    type Output = Self;
18803    #[inline]
18804    fn not(self) -> Self {
18805        Self(!self.0)
18806    }
18807}
18808impl core::fmt::Debug for ShaderCorePropertiesFlagBitsAMD {
18809    #[allow(unused_mut, unused_variables)]
18810    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18811        let mut first = true;
18812        let mut remaining = self.0;
18813        if remaining != 0u32 {
18814            if !first {
18815                f.write_str(" | ")?;
18816            }
18817            write!(f, "{:#x}", remaining)?;
18818        } else if first {
18819            f.write_str("(empty)")?;
18820        }
18821        Ok(())
18822    }
18823}
18824///[`VkShaderCreateFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagBitsEXT.html)
18825#[repr(transparent)]
18826#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
18827#[doc(alias = "VkShaderCreateFlagBitsEXT")]
18828pub struct ShaderCreateFlagBitsEXT(u32);
18829impl ShaderCreateFlagBitsEXT {
18830    #[inline]
18831    pub const fn empty() -> Self {
18832        Self(0u32)
18833    }
18834    #[inline]
18835    pub const fn from_raw(value: u32) -> Self {
18836        Self(value)
18837    }
18838    #[inline]
18839    pub const fn as_raw(self) -> u32 {
18840        self.0
18841    }
18842    #[inline]
18843    pub const fn is_empty(self) -> bool {
18844        self.0 == 0u32
18845    }
18846    #[inline]
18847    pub const fn contains(self, other: Self) -> bool {
18848        (self.0 & other.0) == other.0
18849    }
18850    ///Bit 0.
18851    pub const LINK_STAGE: Self = Self(1u32);
18852    ///Bit 10.
18853    pub const DESCRIPTOR_HEAP: Self = Self(1024u32);
18854    ///Bit 11.
18855    pub const INSTRUMENT_SHADER_BIT: Self = Self(2048u32);
18856    ///Bit 1.
18857    pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(2u32);
18858    ///Bit 2.
18859    pub const REQUIRE_FULL_SUBGROUPS: Self = Self(4u32);
18860    ///Bit 3.
18861    pub const NO_TASK_SHADER: Self = Self(8u32);
18862    ///Bit 4.
18863    pub const DISPATCH_BASE: Self = Self(16u32);
18864    ///Bit 5.
18865    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(32u32);
18866    ///Bit 6.
18867    pub const FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(64u32);
18868    ///Bit 7.
18869    pub const INDIRECT_BINDABLE: Self = Self(128u32);
18870    ///Bit 15.
18871    pub const _64_BIT_INDEXING: Self = Self(32768u32);
18872}
18873impl core::ops::BitOr for ShaderCreateFlagBitsEXT {
18874    type Output = Self;
18875    #[inline]
18876    fn bitor(self, rhs: Self) -> Self {
18877        Self(self.0 | rhs.0)
18878    }
18879}
18880impl core::ops::BitOrAssign for ShaderCreateFlagBitsEXT {
18881    #[inline]
18882    fn bitor_assign(&mut self, rhs: Self) {
18883        self.0 |= rhs.0;
18884    }
18885}
18886impl core::ops::BitAnd for ShaderCreateFlagBitsEXT {
18887    type Output = Self;
18888    #[inline]
18889    fn bitand(self, rhs: Self) -> Self {
18890        Self(self.0 & rhs.0)
18891    }
18892}
18893impl core::ops::BitAndAssign for ShaderCreateFlagBitsEXT {
18894    #[inline]
18895    fn bitand_assign(&mut self, rhs: Self) {
18896        self.0 &= rhs.0;
18897    }
18898}
18899impl core::ops::BitXor for ShaderCreateFlagBitsEXT {
18900    type Output = Self;
18901    #[inline]
18902    fn bitxor(self, rhs: Self) -> Self {
18903        Self(self.0 ^ rhs.0)
18904    }
18905}
18906impl core::ops::BitXorAssign for ShaderCreateFlagBitsEXT {
18907    #[inline]
18908    fn bitxor_assign(&mut self, rhs: Self) {
18909        self.0 ^= rhs.0;
18910    }
18911}
18912impl core::ops::Not for ShaderCreateFlagBitsEXT {
18913    type Output = Self;
18914    #[inline]
18915    fn not(self) -> Self {
18916        Self(!self.0)
18917    }
18918}
18919impl core::fmt::Debug for ShaderCreateFlagBitsEXT {
18920    #[allow(unused_mut, unused_variables)]
18921    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
18922        let mut first = true;
18923        let mut remaining = self.0;
18924        if remaining & Self::LINK_STAGE.0 != 0 {
18925            if !first {
18926                f.write_str(" | ")?;
18927            }
18928            f.write_str("LINK_STAGE")?;
18929            remaining &= !Self::LINK_STAGE.0;
18930            first = false;
18931        }
18932        if remaining & Self::DESCRIPTOR_HEAP.0 != 0 {
18933            if !first {
18934                f.write_str(" | ")?;
18935            }
18936            f.write_str("DESCRIPTOR_HEAP")?;
18937            remaining &= !Self::DESCRIPTOR_HEAP.0;
18938            first = false;
18939        }
18940        if remaining & Self::INSTRUMENT_SHADER_BIT.0 != 0 {
18941            if !first {
18942                f.write_str(" | ")?;
18943            }
18944            f.write_str("INSTRUMENT_SHADER_BIT")?;
18945            remaining &= !Self::INSTRUMENT_SHADER_BIT.0;
18946            first = false;
18947        }
18948        if remaining & Self::ALLOW_VARYING_SUBGROUP_SIZE.0 != 0 {
18949            if !first {
18950                f.write_str(" | ")?;
18951            }
18952            f.write_str("ALLOW_VARYING_SUBGROUP_SIZE")?;
18953            remaining &= !Self::ALLOW_VARYING_SUBGROUP_SIZE.0;
18954            first = false;
18955        }
18956        if remaining & Self::REQUIRE_FULL_SUBGROUPS.0 != 0 {
18957            if !first {
18958                f.write_str(" | ")?;
18959            }
18960            f.write_str("REQUIRE_FULL_SUBGROUPS")?;
18961            remaining &= !Self::REQUIRE_FULL_SUBGROUPS.0;
18962            first = false;
18963        }
18964        if remaining & Self::NO_TASK_SHADER.0 != 0 {
18965            if !first {
18966                f.write_str(" | ")?;
18967            }
18968            f.write_str("NO_TASK_SHADER")?;
18969            remaining &= !Self::NO_TASK_SHADER.0;
18970            first = false;
18971        }
18972        if remaining & Self::DISPATCH_BASE.0 != 0 {
18973            if !first {
18974                f.write_str(" | ")?;
18975            }
18976            f.write_str("DISPATCH_BASE")?;
18977            remaining &= !Self::DISPATCH_BASE.0;
18978            first = false;
18979        }
18980        if remaining & Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0 != 0 {
18981            if !first {
18982                f.write_str(" | ")?;
18983            }
18984            f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT")?;
18985            remaining &= !Self::FRAGMENT_SHADING_RATE_ATTACHMENT.0;
18986            first = false;
18987        }
18988        if remaining & Self::FRAGMENT_DENSITY_MAP_ATTACHMENT.0 != 0 {
18989            if !first {
18990                f.write_str(" | ")?;
18991            }
18992            f.write_str("FRAGMENT_DENSITY_MAP_ATTACHMENT")?;
18993            remaining &= !Self::FRAGMENT_DENSITY_MAP_ATTACHMENT.0;
18994            first = false;
18995        }
18996        if remaining & Self::INDIRECT_BINDABLE.0 != 0 {
18997            if !first {
18998                f.write_str(" | ")?;
18999            }
19000            f.write_str("INDIRECT_BINDABLE")?;
19001            remaining &= !Self::INDIRECT_BINDABLE.0;
19002            first = false;
19003        }
19004        if remaining & Self::_64_BIT_INDEXING.0 != 0 {
19005            if !first {
19006                f.write_str(" | ")?;
19007            }
19008            f.write_str("_64_BIT_INDEXING")?;
19009            remaining &= !Self::_64_BIT_INDEXING.0;
19010            first = false;
19011        }
19012        if remaining != 0u32 {
19013            if !first {
19014                f.write_str(" | ")?;
19015            }
19016            write!(f, "{:#x}", remaining)?;
19017        } else if first {
19018            f.write_str("(empty)")?;
19019        }
19020        Ok(())
19021    }
19022}
19023///[`VkShaderModuleCreateFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleCreateFlagBits.html)
19024#[repr(transparent)]
19025#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
19026#[doc(alias = "VkShaderModuleCreateFlagBits")]
19027pub struct ShaderModuleCreateFlagBits(u32);
19028impl ShaderModuleCreateFlagBits {
19029    #[inline]
19030    pub const fn empty() -> Self {
19031        Self(0u32)
19032    }
19033    #[inline]
19034    pub const fn from_raw(value: u32) -> Self {
19035        Self(value)
19036    }
19037    #[inline]
19038    pub const fn as_raw(self) -> u32 {
19039        self.0
19040    }
19041    #[inline]
19042    pub const fn is_empty(self) -> bool {
19043        self.0 == 0u32
19044    }
19045    #[inline]
19046    pub const fn contains(self, other: Self) -> bool {
19047        (self.0 & other.0) == other.0
19048    }
19049}
19050impl core::ops::BitOr for ShaderModuleCreateFlagBits {
19051    type Output = Self;
19052    #[inline]
19053    fn bitor(self, rhs: Self) -> Self {
19054        Self(self.0 | rhs.0)
19055    }
19056}
19057impl core::ops::BitOrAssign for ShaderModuleCreateFlagBits {
19058    #[inline]
19059    fn bitor_assign(&mut self, rhs: Self) {
19060        self.0 |= rhs.0;
19061    }
19062}
19063impl core::ops::BitAnd for ShaderModuleCreateFlagBits {
19064    type Output = Self;
19065    #[inline]
19066    fn bitand(self, rhs: Self) -> Self {
19067        Self(self.0 & rhs.0)
19068    }
19069}
19070impl core::ops::BitAndAssign for ShaderModuleCreateFlagBits {
19071    #[inline]
19072    fn bitand_assign(&mut self, rhs: Self) {
19073        self.0 &= rhs.0;
19074    }
19075}
19076impl core::ops::BitXor for ShaderModuleCreateFlagBits {
19077    type Output = Self;
19078    #[inline]
19079    fn bitxor(self, rhs: Self) -> Self {
19080        Self(self.0 ^ rhs.0)
19081    }
19082}
19083impl core::ops::BitXorAssign for ShaderModuleCreateFlagBits {
19084    #[inline]
19085    fn bitxor_assign(&mut self, rhs: Self) {
19086        self.0 ^= rhs.0;
19087    }
19088}
19089impl core::ops::Not for ShaderModuleCreateFlagBits {
19090    type Output = Self;
19091    #[inline]
19092    fn not(self) -> Self {
19093        Self(!self.0)
19094    }
19095}
19096impl core::fmt::Debug for ShaderModuleCreateFlagBits {
19097    #[allow(unused_mut, unused_variables)]
19098    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19099        let mut first = true;
19100        let mut remaining = self.0;
19101        if remaining != 0u32 {
19102            if !first {
19103                f.write_str(" | ")?;
19104            }
19105            write!(f, "{:#x}", remaining)?;
19106        } else if first {
19107            f.write_str("(empty)")?;
19108        }
19109        Ok(())
19110    }
19111}
19112///[`VkShaderStageFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderStageFlagBits.html)
19113#[repr(transparent)]
19114#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
19115#[doc(alias = "VkShaderStageFlagBits")]
19116pub struct ShaderStageFlagBits(u32);
19117impl ShaderStageFlagBits {
19118    #[inline]
19119    pub const fn empty() -> Self {
19120        Self(0u32)
19121    }
19122    #[inline]
19123    pub const fn from_raw(value: u32) -> Self {
19124        Self(value)
19125    }
19126    #[inline]
19127    pub const fn as_raw(self) -> u32 {
19128        self.0
19129    }
19130    #[inline]
19131    pub const fn is_empty(self) -> bool {
19132        self.0 == 0u32
19133    }
19134    #[inline]
19135    pub const fn contains(self, other: Self) -> bool {
19136        (self.0 & other.0) == other.0
19137    }
19138    ///Bit 0.
19139    pub const VERTEX: Self = Self(1u32);
19140    ///Bit 1.
19141    pub const TESSELLATION_CONTROL: Self = Self(2u32);
19142    ///Bit 2.
19143    pub const TESSELLATION_EVALUATION: Self = Self(4u32);
19144    ///Bit 3.
19145    pub const GEOMETRY: Self = Self(8u32);
19146    ///Bit 4.
19147    pub const FRAGMENT: Self = Self(16u32);
19148    ///Bit 5.
19149    pub const COMPUTE: Self = Self(32u32);
19150    pub const ALL_GRAPHICS: Self = Self(31u32);
19151    pub const ALL: Self = Self(2147483647u32);
19152    ///Bit 8.
19153    pub const RAYGEN: Self = Self(256u32);
19154    ///Bit 9.
19155    pub const ANY_HIT: Self = Self(512u32);
19156    ///Bit 10.
19157    pub const CLOSEST_HIT: Self = Self(1024u32);
19158    ///Bit 11.
19159    pub const MISS: Self = Self(2048u32);
19160    ///Bit 12.
19161    pub const INTERSECTION: Self = Self(4096u32);
19162    ///Bit 13.
19163    pub const CALLABLE: Self = Self(8192u32);
19164    ///Bit 14.
19165    pub const SUBPASS_SHADING_BIT: Self = Self(16384u32);
19166    ///Bit 19.
19167    pub const CLUSTER_CULLING_BIT: Self = Self(524288u32);
19168}
19169impl core::ops::BitOr for ShaderStageFlagBits {
19170    type Output = Self;
19171    #[inline]
19172    fn bitor(self, rhs: Self) -> Self {
19173        Self(self.0 | rhs.0)
19174    }
19175}
19176impl core::ops::BitOrAssign for ShaderStageFlagBits {
19177    #[inline]
19178    fn bitor_assign(&mut self, rhs: Self) {
19179        self.0 |= rhs.0;
19180    }
19181}
19182impl core::ops::BitAnd for ShaderStageFlagBits {
19183    type Output = Self;
19184    #[inline]
19185    fn bitand(self, rhs: Self) -> Self {
19186        Self(self.0 & rhs.0)
19187    }
19188}
19189impl core::ops::BitAndAssign for ShaderStageFlagBits {
19190    #[inline]
19191    fn bitand_assign(&mut self, rhs: Self) {
19192        self.0 &= rhs.0;
19193    }
19194}
19195impl core::ops::BitXor for ShaderStageFlagBits {
19196    type Output = Self;
19197    #[inline]
19198    fn bitxor(self, rhs: Self) -> Self {
19199        Self(self.0 ^ rhs.0)
19200    }
19201}
19202impl core::ops::BitXorAssign for ShaderStageFlagBits {
19203    #[inline]
19204    fn bitxor_assign(&mut self, rhs: Self) {
19205        self.0 ^= rhs.0;
19206    }
19207}
19208impl core::ops::Not for ShaderStageFlagBits {
19209    type Output = Self;
19210    #[inline]
19211    fn not(self) -> Self {
19212        Self(!self.0)
19213    }
19214}
19215impl core::fmt::Debug for ShaderStageFlagBits {
19216    #[allow(unused_mut, unused_variables)]
19217    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19218        let mut first = true;
19219        let mut remaining = self.0;
19220        if remaining & Self::VERTEX.0 != 0 {
19221            if !first {
19222                f.write_str(" | ")?;
19223            }
19224            f.write_str("VERTEX")?;
19225            remaining &= !Self::VERTEX.0;
19226            first = false;
19227        }
19228        if remaining & Self::TESSELLATION_CONTROL.0 != 0 {
19229            if !first {
19230                f.write_str(" | ")?;
19231            }
19232            f.write_str("TESSELLATION_CONTROL")?;
19233            remaining &= !Self::TESSELLATION_CONTROL.0;
19234            first = false;
19235        }
19236        if remaining & Self::TESSELLATION_EVALUATION.0 != 0 {
19237            if !first {
19238                f.write_str(" | ")?;
19239            }
19240            f.write_str("TESSELLATION_EVALUATION")?;
19241            remaining &= !Self::TESSELLATION_EVALUATION.0;
19242            first = false;
19243        }
19244        if remaining & Self::GEOMETRY.0 != 0 {
19245            if !first {
19246                f.write_str(" | ")?;
19247            }
19248            f.write_str("GEOMETRY")?;
19249            remaining &= !Self::GEOMETRY.0;
19250            first = false;
19251        }
19252        if remaining & Self::FRAGMENT.0 != 0 {
19253            if !first {
19254                f.write_str(" | ")?;
19255            }
19256            f.write_str("FRAGMENT")?;
19257            remaining &= !Self::FRAGMENT.0;
19258            first = false;
19259        }
19260        if remaining & Self::COMPUTE.0 != 0 {
19261            if !first {
19262                f.write_str(" | ")?;
19263            }
19264            f.write_str("COMPUTE")?;
19265            remaining &= !Self::COMPUTE.0;
19266            first = false;
19267        }
19268        if remaining & Self::RAYGEN.0 != 0 {
19269            if !first {
19270                f.write_str(" | ")?;
19271            }
19272            f.write_str("RAYGEN")?;
19273            remaining &= !Self::RAYGEN.0;
19274            first = false;
19275        }
19276        if remaining & Self::ANY_HIT.0 != 0 {
19277            if !first {
19278                f.write_str(" | ")?;
19279            }
19280            f.write_str("ANY_HIT")?;
19281            remaining &= !Self::ANY_HIT.0;
19282            first = false;
19283        }
19284        if remaining & Self::CLOSEST_HIT.0 != 0 {
19285            if !first {
19286                f.write_str(" | ")?;
19287            }
19288            f.write_str("CLOSEST_HIT")?;
19289            remaining &= !Self::CLOSEST_HIT.0;
19290            first = false;
19291        }
19292        if remaining & Self::MISS.0 != 0 {
19293            if !first {
19294                f.write_str(" | ")?;
19295            }
19296            f.write_str("MISS")?;
19297            remaining &= !Self::MISS.0;
19298            first = false;
19299        }
19300        if remaining & Self::INTERSECTION.0 != 0 {
19301            if !first {
19302                f.write_str(" | ")?;
19303            }
19304            f.write_str("INTERSECTION")?;
19305            remaining &= !Self::INTERSECTION.0;
19306            first = false;
19307        }
19308        if remaining & Self::CALLABLE.0 != 0 {
19309            if !first {
19310                f.write_str(" | ")?;
19311            }
19312            f.write_str("CALLABLE")?;
19313            remaining &= !Self::CALLABLE.0;
19314            first = false;
19315        }
19316        if remaining & Self::SUBPASS_SHADING_BIT.0 != 0 {
19317            if !first {
19318                f.write_str(" | ")?;
19319            }
19320            f.write_str("SUBPASS_SHADING_BIT")?;
19321            remaining &= !Self::SUBPASS_SHADING_BIT.0;
19322            first = false;
19323        }
19324        if remaining & Self::CLUSTER_CULLING_BIT.0 != 0 {
19325            if !first {
19326                f.write_str(" | ")?;
19327            }
19328            f.write_str("CLUSTER_CULLING_BIT")?;
19329            remaining &= !Self::CLUSTER_CULLING_BIT.0;
19330            first = false;
19331        }
19332        if remaining != 0u32 {
19333            if !first {
19334                f.write_str(" | ")?;
19335            }
19336            write!(f, "{:#x}", remaining)?;
19337        } else if first {
19338            f.write_str("(empty)")?;
19339        }
19340        Ok(())
19341    }
19342}
19343///[`VkSparseImageFormatFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatFlagBits.html)
19344#[repr(transparent)]
19345#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
19346#[doc(alias = "VkSparseImageFormatFlagBits")]
19347pub struct SparseImageFormatFlagBits(u32);
19348impl SparseImageFormatFlagBits {
19349    #[inline]
19350    pub const fn empty() -> Self {
19351        Self(0u32)
19352    }
19353    #[inline]
19354    pub const fn from_raw(value: u32) -> Self {
19355        Self(value)
19356    }
19357    #[inline]
19358    pub const fn as_raw(self) -> u32 {
19359        self.0
19360    }
19361    #[inline]
19362    pub const fn is_empty(self) -> bool {
19363        self.0 == 0u32
19364    }
19365    #[inline]
19366    pub const fn contains(self, other: Self) -> bool {
19367        (self.0 & other.0) == other.0
19368    }
19369    ///Bit 0.
19370    pub const SINGLE_MIPTAIL: Self = Self(1u32);
19371    ///Bit 1.
19372    pub const ALIGNED_MIP_SIZE: Self = Self(2u32);
19373    ///Bit 2.
19374    pub const NONSTANDARD_BLOCK_SIZE: Self = Self(4u32);
19375}
19376impl core::ops::BitOr for SparseImageFormatFlagBits {
19377    type Output = Self;
19378    #[inline]
19379    fn bitor(self, rhs: Self) -> Self {
19380        Self(self.0 | rhs.0)
19381    }
19382}
19383impl core::ops::BitOrAssign for SparseImageFormatFlagBits {
19384    #[inline]
19385    fn bitor_assign(&mut self, rhs: Self) {
19386        self.0 |= rhs.0;
19387    }
19388}
19389impl core::ops::BitAnd for SparseImageFormatFlagBits {
19390    type Output = Self;
19391    #[inline]
19392    fn bitand(self, rhs: Self) -> Self {
19393        Self(self.0 & rhs.0)
19394    }
19395}
19396impl core::ops::BitAndAssign for SparseImageFormatFlagBits {
19397    #[inline]
19398    fn bitand_assign(&mut self, rhs: Self) {
19399        self.0 &= rhs.0;
19400    }
19401}
19402impl core::ops::BitXor for SparseImageFormatFlagBits {
19403    type Output = Self;
19404    #[inline]
19405    fn bitxor(self, rhs: Self) -> Self {
19406        Self(self.0 ^ rhs.0)
19407    }
19408}
19409impl core::ops::BitXorAssign for SparseImageFormatFlagBits {
19410    #[inline]
19411    fn bitxor_assign(&mut self, rhs: Self) {
19412        self.0 ^= rhs.0;
19413    }
19414}
19415impl core::ops::Not for SparseImageFormatFlagBits {
19416    type Output = Self;
19417    #[inline]
19418    fn not(self) -> Self {
19419        Self(!self.0)
19420    }
19421}
19422impl core::fmt::Debug for SparseImageFormatFlagBits {
19423    #[allow(unused_mut, unused_variables)]
19424    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19425        let mut first = true;
19426        let mut remaining = self.0;
19427        if remaining & Self::SINGLE_MIPTAIL.0 != 0 {
19428            if !first {
19429                f.write_str(" | ")?;
19430            }
19431            f.write_str("SINGLE_MIPTAIL")?;
19432            remaining &= !Self::SINGLE_MIPTAIL.0;
19433            first = false;
19434        }
19435        if remaining & Self::ALIGNED_MIP_SIZE.0 != 0 {
19436            if !first {
19437                f.write_str(" | ")?;
19438            }
19439            f.write_str("ALIGNED_MIP_SIZE")?;
19440            remaining &= !Self::ALIGNED_MIP_SIZE.0;
19441            first = false;
19442        }
19443        if remaining & Self::NONSTANDARD_BLOCK_SIZE.0 != 0 {
19444            if !first {
19445                f.write_str(" | ")?;
19446            }
19447            f.write_str("NONSTANDARD_BLOCK_SIZE")?;
19448            remaining &= !Self::NONSTANDARD_BLOCK_SIZE.0;
19449            first = false;
19450        }
19451        if remaining != 0u32 {
19452            if !first {
19453                f.write_str(" | ")?;
19454            }
19455            write!(f, "{:#x}", remaining)?;
19456        } else if first {
19457            f.write_str("(empty)")?;
19458        }
19459        Ok(())
19460    }
19461}
19462///[`VkSparseMemoryBindFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBindFlagBits.html)
19463#[repr(transparent)]
19464#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
19465#[doc(alias = "VkSparseMemoryBindFlagBits")]
19466pub struct SparseMemoryBindFlagBits(u32);
19467impl SparseMemoryBindFlagBits {
19468    #[inline]
19469    pub const fn empty() -> Self {
19470        Self(0u32)
19471    }
19472    #[inline]
19473    pub const fn from_raw(value: u32) -> Self {
19474        Self(value)
19475    }
19476    #[inline]
19477    pub const fn as_raw(self) -> u32 {
19478        self.0
19479    }
19480    #[inline]
19481    pub const fn is_empty(self) -> bool {
19482        self.0 == 0u32
19483    }
19484    #[inline]
19485    pub const fn contains(self, other: Self) -> bool {
19486        (self.0 & other.0) == other.0
19487    }
19488    ///Bit 0.
19489    pub const METADATA: Self = Self(1u32);
19490}
19491impl core::ops::BitOr for SparseMemoryBindFlagBits {
19492    type Output = Self;
19493    #[inline]
19494    fn bitor(self, rhs: Self) -> Self {
19495        Self(self.0 | rhs.0)
19496    }
19497}
19498impl core::ops::BitOrAssign for SparseMemoryBindFlagBits {
19499    #[inline]
19500    fn bitor_assign(&mut self, rhs: Self) {
19501        self.0 |= rhs.0;
19502    }
19503}
19504impl core::ops::BitAnd for SparseMemoryBindFlagBits {
19505    type Output = Self;
19506    #[inline]
19507    fn bitand(self, rhs: Self) -> Self {
19508        Self(self.0 & rhs.0)
19509    }
19510}
19511impl core::ops::BitAndAssign for SparseMemoryBindFlagBits {
19512    #[inline]
19513    fn bitand_assign(&mut self, rhs: Self) {
19514        self.0 &= rhs.0;
19515    }
19516}
19517impl core::ops::BitXor for SparseMemoryBindFlagBits {
19518    type Output = Self;
19519    #[inline]
19520    fn bitxor(self, rhs: Self) -> Self {
19521        Self(self.0 ^ rhs.0)
19522    }
19523}
19524impl core::ops::BitXorAssign for SparseMemoryBindFlagBits {
19525    #[inline]
19526    fn bitxor_assign(&mut self, rhs: Self) {
19527        self.0 ^= rhs.0;
19528    }
19529}
19530impl core::ops::Not for SparseMemoryBindFlagBits {
19531    type Output = Self;
19532    #[inline]
19533    fn not(self) -> Self {
19534        Self(!self.0)
19535    }
19536}
19537impl core::fmt::Debug for SparseMemoryBindFlagBits {
19538    #[allow(unused_mut, unused_variables)]
19539    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19540        let mut first = true;
19541        let mut remaining = self.0;
19542        if remaining & Self::METADATA.0 != 0 {
19543            if !first {
19544                f.write_str(" | ")?;
19545            }
19546            f.write_str("METADATA")?;
19547            remaining &= !Self::METADATA.0;
19548            first = false;
19549        }
19550        if remaining != 0u32 {
19551            if !first {
19552                f.write_str(" | ")?;
19553            }
19554            write!(f, "{:#x}", remaining)?;
19555        } else if first {
19556            f.write_str("(empty)")?;
19557        }
19558        Ok(())
19559    }
19560}
19561///[`VkSpirvResourceTypeFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpirvResourceTypeFlagBitsEXT.html)
19562#[repr(transparent)]
19563#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
19564#[doc(alias = "VkSpirvResourceTypeFlagBitsEXT")]
19565pub struct SpirvResourceTypeFlagBitsEXT(u32);
19566impl SpirvResourceTypeFlagBitsEXT {
19567    #[inline]
19568    pub const fn empty() -> Self {
19569        Self(0u32)
19570    }
19571    #[inline]
19572    pub const fn from_raw(value: u32) -> Self {
19573        Self(value)
19574    }
19575    #[inline]
19576    pub const fn as_raw(self) -> u32 {
19577        self.0
19578    }
19579    #[inline]
19580    pub const fn is_empty(self) -> bool {
19581        self.0 == 0u32
19582    }
19583    #[inline]
19584    pub const fn contains(self, other: Self) -> bool {
19585        (self.0 & other.0) == other.0
19586    }
19587    pub const ALL: Self = Self(2147483647u32);
19588    ///Bit 0.
19589    pub const SAMPLER: Self = Self(1u32);
19590    ///Bit 1.
19591    pub const SAMPLED_IMAGE: Self = Self(2u32);
19592    ///Bit 2.
19593    pub const READ_ONLY_IMAGE: Self = Self(4u32);
19594    ///Bit 3.
19595    pub const READ_WRITE_IMAGE: Self = Self(8u32);
19596    ///Bit 4.
19597    pub const COMBINED_SAMPLED_IMAGE: Self = Self(16u32);
19598    ///Bit 5.
19599    pub const UNIFORM_BUFFER: Self = Self(32u32);
19600    ///Bit 6.
19601    pub const READ_ONLY_STORAGE_BUFFER: Self = Self(64u32);
19602    ///Bit 7.
19603    pub const READ_WRITE_STORAGE_BUFFER: Self = Self(128u32);
19604    ///Bit 8.
19605    pub const ACCELERATION_STRUCTURE: Self = Self(256u32);
19606    ///Bit 9.
19607    pub const TENSOR_BIT: Self = Self(512u32);
19608}
19609impl core::ops::BitOr for SpirvResourceTypeFlagBitsEXT {
19610    type Output = Self;
19611    #[inline]
19612    fn bitor(self, rhs: Self) -> Self {
19613        Self(self.0 | rhs.0)
19614    }
19615}
19616impl core::ops::BitOrAssign for SpirvResourceTypeFlagBitsEXT {
19617    #[inline]
19618    fn bitor_assign(&mut self, rhs: Self) {
19619        self.0 |= rhs.0;
19620    }
19621}
19622impl core::ops::BitAnd for SpirvResourceTypeFlagBitsEXT {
19623    type Output = Self;
19624    #[inline]
19625    fn bitand(self, rhs: Self) -> Self {
19626        Self(self.0 & rhs.0)
19627    }
19628}
19629impl core::ops::BitAndAssign for SpirvResourceTypeFlagBitsEXT {
19630    #[inline]
19631    fn bitand_assign(&mut self, rhs: Self) {
19632        self.0 &= rhs.0;
19633    }
19634}
19635impl core::ops::BitXor for SpirvResourceTypeFlagBitsEXT {
19636    type Output = Self;
19637    #[inline]
19638    fn bitxor(self, rhs: Self) -> Self {
19639        Self(self.0 ^ rhs.0)
19640    }
19641}
19642impl core::ops::BitXorAssign for SpirvResourceTypeFlagBitsEXT {
19643    #[inline]
19644    fn bitxor_assign(&mut self, rhs: Self) {
19645        self.0 ^= rhs.0;
19646    }
19647}
19648impl core::ops::Not for SpirvResourceTypeFlagBitsEXT {
19649    type Output = Self;
19650    #[inline]
19651    fn not(self) -> Self {
19652        Self(!self.0)
19653    }
19654}
19655impl core::fmt::Debug for SpirvResourceTypeFlagBitsEXT {
19656    #[allow(unused_mut, unused_variables)]
19657    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19658        let mut first = true;
19659        let mut remaining = self.0;
19660        if remaining & Self::SAMPLER.0 != 0 {
19661            if !first {
19662                f.write_str(" | ")?;
19663            }
19664            f.write_str("SAMPLER")?;
19665            remaining &= !Self::SAMPLER.0;
19666            first = false;
19667        }
19668        if remaining & Self::SAMPLED_IMAGE.0 != 0 {
19669            if !first {
19670                f.write_str(" | ")?;
19671            }
19672            f.write_str("SAMPLED_IMAGE")?;
19673            remaining &= !Self::SAMPLED_IMAGE.0;
19674            first = false;
19675        }
19676        if remaining & Self::READ_ONLY_IMAGE.0 != 0 {
19677            if !first {
19678                f.write_str(" | ")?;
19679            }
19680            f.write_str("READ_ONLY_IMAGE")?;
19681            remaining &= !Self::READ_ONLY_IMAGE.0;
19682            first = false;
19683        }
19684        if remaining & Self::READ_WRITE_IMAGE.0 != 0 {
19685            if !first {
19686                f.write_str(" | ")?;
19687            }
19688            f.write_str("READ_WRITE_IMAGE")?;
19689            remaining &= !Self::READ_WRITE_IMAGE.0;
19690            first = false;
19691        }
19692        if remaining & Self::COMBINED_SAMPLED_IMAGE.0 != 0 {
19693            if !first {
19694                f.write_str(" | ")?;
19695            }
19696            f.write_str("COMBINED_SAMPLED_IMAGE")?;
19697            remaining &= !Self::COMBINED_SAMPLED_IMAGE.0;
19698            first = false;
19699        }
19700        if remaining & Self::UNIFORM_BUFFER.0 != 0 {
19701            if !first {
19702                f.write_str(" | ")?;
19703            }
19704            f.write_str("UNIFORM_BUFFER")?;
19705            remaining &= !Self::UNIFORM_BUFFER.0;
19706            first = false;
19707        }
19708        if remaining & Self::READ_ONLY_STORAGE_BUFFER.0 != 0 {
19709            if !first {
19710                f.write_str(" | ")?;
19711            }
19712            f.write_str("READ_ONLY_STORAGE_BUFFER")?;
19713            remaining &= !Self::READ_ONLY_STORAGE_BUFFER.0;
19714            first = false;
19715        }
19716        if remaining & Self::READ_WRITE_STORAGE_BUFFER.0 != 0 {
19717            if !first {
19718                f.write_str(" | ")?;
19719            }
19720            f.write_str("READ_WRITE_STORAGE_BUFFER")?;
19721            remaining &= !Self::READ_WRITE_STORAGE_BUFFER.0;
19722            first = false;
19723        }
19724        if remaining & Self::ACCELERATION_STRUCTURE.0 != 0 {
19725            if !first {
19726                f.write_str(" | ")?;
19727            }
19728            f.write_str("ACCELERATION_STRUCTURE")?;
19729            remaining &= !Self::ACCELERATION_STRUCTURE.0;
19730            first = false;
19731        }
19732        if remaining & Self::TENSOR_BIT.0 != 0 {
19733            if !first {
19734                f.write_str(" | ")?;
19735            }
19736            f.write_str("TENSOR_BIT")?;
19737            remaining &= !Self::TENSOR_BIT.0;
19738            first = false;
19739        }
19740        if remaining != 0u32 {
19741            if !first {
19742                f.write_str(" | ")?;
19743            }
19744            write!(f, "{:#x}", remaining)?;
19745        } else if first {
19746            f.write_str("(empty)")?;
19747        }
19748        Ok(())
19749    }
19750}
19751///[`VkStencilFaceFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilFaceFlagBits.html)
19752#[repr(transparent)]
19753#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
19754#[doc(alias = "VkStencilFaceFlagBits")]
19755pub struct StencilFaceFlagBits(u32);
19756impl StencilFaceFlagBits {
19757    #[inline]
19758    pub const fn empty() -> Self {
19759        Self(0u32)
19760    }
19761    #[inline]
19762    pub const fn from_raw(value: u32) -> Self {
19763        Self(value)
19764    }
19765    #[inline]
19766    pub const fn as_raw(self) -> u32 {
19767        self.0
19768    }
19769    #[inline]
19770    pub const fn is_empty(self) -> bool {
19771        self.0 == 0u32
19772    }
19773    #[inline]
19774    pub const fn contains(self, other: Self) -> bool {
19775        (self.0 & other.0) == other.0
19776    }
19777    ///Bit 0.
19778    pub const FRONT: Self = Self(1u32);
19779    ///Bit 1.
19780    pub const BACK: Self = Self(2u32);
19781    pub const FRONT_AND_BACK: Self = Self(3u32);
19782    pub const STENCIL_FRONT_AND_BACK: Self = Self::FRONT_AND_BACK;
19783}
19784impl core::ops::BitOr for StencilFaceFlagBits {
19785    type Output = Self;
19786    #[inline]
19787    fn bitor(self, rhs: Self) -> Self {
19788        Self(self.0 | rhs.0)
19789    }
19790}
19791impl core::ops::BitOrAssign for StencilFaceFlagBits {
19792    #[inline]
19793    fn bitor_assign(&mut self, rhs: Self) {
19794        self.0 |= rhs.0;
19795    }
19796}
19797impl core::ops::BitAnd for StencilFaceFlagBits {
19798    type Output = Self;
19799    #[inline]
19800    fn bitand(self, rhs: Self) -> Self {
19801        Self(self.0 & rhs.0)
19802    }
19803}
19804impl core::ops::BitAndAssign for StencilFaceFlagBits {
19805    #[inline]
19806    fn bitand_assign(&mut self, rhs: Self) {
19807        self.0 &= rhs.0;
19808    }
19809}
19810impl core::ops::BitXor for StencilFaceFlagBits {
19811    type Output = Self;
19812    #[inline]
19813    fn bitxor(self, rhs: Self) -> Self {
19814        Self(self.0 ^ rhs.0)
19815    }
19816}
19817impl core::ops::BitXorAssign for StencilFaceFlagBits {
19818    #[inline]
19819    fn bitxor_assign(&mut self, rhs: Self) {
19820        self.0 ^= rhs.0;
19821    }
19822}
19823impl core::ops::Not for StencilFaceFlagBits {
19824    type Output = Self;
19825    #[inline]
19826    fn not(self) -> Self {
19827        Self(!self.0)
19828    }
19829}
19830impl core::fmt::Debug for StencilFaceFlagBits {
19831    #[allow(unused_mut, unused_variables)]
19832    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19833        let mut first = true;
19834        let mut remaining = self.0;
19835        if remaining & Self::FRONT.0 != 0 {
19836            if !first {
19837                f.write_str(" | ")?;
19838            }
19839            f.write_str("FRONT")?;
19840            remaining &= !Self::FRONT.0;
19841            first = false;
19842        }
19843        if remaining & Self::BACK.0 != 0 {
19844            if !first {
19845                f.write_str(" | ")?;
19846            }
19847            f.write_str("BACK")?;
19848            remaining &= !Self::BACK.0;
19849            first = false;
19850        }
19851        if remaining != 0u32 {
19852            if !first {
19853                f.write_str(" | ")?;
19854            }
19855            write!(f, "{:#x}", remaining)?;
19856        } else if first {
19857            f.write_str("(empty)")?;
19858        }
19859        Ok(())
19860    }
19861}
19862///[`VkSubgroupFeatureFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubgroupFeatureFlagBits.html)
19863#[repr(transparent)]
19864#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
19865#[doc(alias = "VkSubgroupFeatureFlagBits")]
19866pub struct SubgroupFeatureFlagBits(u32);
19867impl SubgroupFeatureFlagBits {
19868    #[inline]
19869    pub const fn empty() -> Self {
19870        Self(0u32)
19871    }
19872    #[inline]
19873    pub const fn from_raw(value: u32) -> Self {
19874        Self(value)
19875    }
19876    #[inline]
19877    pub const fn as_raw(self) -> u32 {
19878        self.0
19879    }
19880    #[inline]
19881    pub const fn is_empty(self) -> bool {
19882        self.0 == 0u32
19883    }
19884    #[inline]
19885    pub const fn contains(self, other: Self) -> bool {
19886        (self.0 & other.0) == other.0
19887    }
19888    ///Bit 0.
19889    pub const BASIC: Self = Self(1u32);
19890    ///Bit 1.
19891    pub const VOTE: Self = Self(2u32);
19892    ///Bit 2.
19893    pub const ARITHMETIC: Self = Self(4u32);
19894    ///Bit 3.
19895    pub const BALLOT: Self = Self(8u32);
19896    ///Bit 4.
19897    pub const SHUFFLE: Self = Self(16u32);
19898    ///Bit 5.
19899    pub const SHUFFLE_RELATIVE: Self = Self(32u32);
19900    ///Bit 6.
19901    pub const CLUSTERED: Self = Self(64u32);
19902    ///Bit 7.
19903    pub const QUAD: Self = Self(128u32);
19904    ///Bit 9.
19905    pub const ROTATE: Self = Self(512u32);
19906    ///Bit 10.
19907    pub const ROTATE_CLUSTERED: Self = Self(1024u32);
19908}
19909impl core::ops::BitOr for SubgroupFeatureFlagBits {
19910    type Output = Self;
19911    #[inline]
19912    fn bitor(self, rhs: Self) -> Self {
19913        Self(self.0 | rhs.0)
19914    }
19915}
19916impl core::ops::BitOrAssign for SubgroupFeatureFlagBits {
19917    #[inline]
19918    fn bitor_assign(&mut self, rhs: Self) {
19919        self.0 |= rhs.0;
19920    }
19921}
19922impl core::ops::BitAnd for SubgroupFeatureFlagBits {
19923    type Output = Self;
19924    #[inline]
19925    fn bitand(self, rhs: Self) -> Self {
19926        Self(self.0 & rhs.0)
19927    }
19928}
19929impl core::ops::BitAndAssign for SubgroupFeatureFlagBits {
19930    #[inline]
19931    fn bitand_assign(&mut self, rhs: Self) {
19932        self.0 &= rhs.0;
19933    }
19934}
19935impl core::ops::BitXor for SubgroupFeatureFlagBits {
19936    type Output = Self;
19937    #[inline]
19938    fn bitxor(self, rhs: Self) -> Self {
19939        Self(self.0 ^ rhs.0)
19940    }
19941}
19942impl core::ops::BitXorAssign for SubgroupFeatureFlagBits {
19943    #[inline]
19944    fn bitxor_assign(&mut self, rhs: Self) {
19945        self.0 ^= rhs.0;
19946    }
19947}
19948impl core::ops::Not for SubgroupFeatureFlagBits {
19949    type Output = Self;
19950    #[inline]
19951    fn not(self) -> Self {
19952        Self(!self.0)
19953    }
19954}
19955impl core::fmt::Debug for SubgroupFeatureFlagBits {
19956    #[allow(unused_mut, unused_variables)]
19957    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
19958        let mut first = true;
19959        let mut remaining = self.0;
19960        if remaining & Self::BASIC.0 != 0 {
19961            if !first {
19962                f.write_str(" | ")?;
19963            }
19964            f.write_str("BASIC")?;
19965            remaining &= !Self::BASIC.0;
19966            first = false;
19967        }
19968        if remaining & Self::VOTE.0 != 0 {
19969            if !first {
19970                f.write_str(" | ")?;
19971            }
19972            f.write_str("VOTE")?;
19973            remaining &= !Self::VOTE.0;
19974            first = false;
19975        }
19976        if remaining & Self::ARITHMETIC.0 != 0 {
19977            if !first {
19978                f.write_str(" | ")?;
19979            }
19980            f.write_str("ARITHMETIC")?;
19981            remaining &= !Self::ARITHMETIC.0;
19982            first = false;
19983        }
19984        if remaining & Self::BALLOT.0 != 0 {
19985            if !first {
19986                f.write_str(" | ")?;
19987            }
19988            f.write_str("BALLOT")?;
19989            remaining &= !Self::BALLOT.0;
19990            first = false;
19991        }
19992        if remaining & Self::SHUFFLE.0 != 0 {
19993            if !first {
19994                f.write_str(" | ")?;
19995            }
19996            f.write_str("SHUFFLE")?;
19997            remaining &= !Self::SHUFFLE.0;
19998            first = false;
19999        }
20000        if remaining & Self::SHUFFLE_RELATIVE.0 != 0 {
20001            if !first {
20002                f.write_str(" | ")?;
20003            }
20004            f.write_str("SHUFFLE_RELATIVE")?;
20005            remaining &= !Self::SHUFFLE_RELATIVE.0;
20006            first = false;
20007        }
20008        if remaining & Self::CLUSTERED.0 != 0 {
20009            if !first {
20010                f.write_str(" | ")?;
20011            }
20012            f.write_str("CLUSTERED")?;
20013            remaining &= !Self::CLUSTERED.0;
20014            first = false;
20015        }
20016        if remaining & Self::QUAD.0 != 0 {
20017            if !first {
20018                f.write_str(" | ")?;
20019            }
20020            f.write_str("QUAD")?;
20021            remaining &= !Self::QUAD.0;
20022            first = false;
20023        }
20024        if remaining & Self::ROTATE.0 != 0 {
20025            if !first {
20026                f.write_str(" | ")?;
20027            }
20028            f.write_str("ROTATE")?;
20029            remaining &= !Self::ROTATE.0;
20030            first = false;
20031        }
20032        if remaining & Self::ROTATE_CLUSTERED.0 != 0 {
20033            if !first {
20034                f.write_str(" | ")?;
20035            }
20036            f.write_str("ROTATE_CLUSTERED")?;
20037            remaining &= !Self::ROTATE_CLUSTERED.0;
20038            first = false;
20039        }
20040        if remaining != 0u32 {
20041            if !first {
20042                f.write_str(" | ")?;
20043            }
20044            write!(f, "{:#x}", remaining)?;
20045        } else if first {
20046            f.write_str("(empty)")?;
20047        }
20048        Ok(())
20049    }
20050}
20051///[`VkSubmitFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlagBits.html)
20052#[repr(transparent)]
20053#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
20054#[doc(alias = "VkSubmitFlagBits")]
20055pub struct SubmitFlagBits(u32);
20056impl SubmitFlagBits {
20057    #[inline]
20058    pub const fn empty() -> Self {
20059        Self(0u32)
20060    }
20061    #[inline]
20062    pub const fn from_raw(value: u32) -> Self {
20063        Self(value)
20064    }
20065    #[inline]
20066    pub const fn as_raw(self) -> u32 {
20067        self.0
20068    }
20069    #[inline]
20070    pub const fn is_empty(self) -> bool {
20071        self.0 == 0u32
20072    }
20073    #[inline]
20074    pub const fn contains(self, other: Self) -> bool {
20075        (self.0 & other.0) == other.0
20076    }
20077    ///Bit 0.
20078    pub const PROTECTED: Self = Self(1u32);
20079}
20080impl core::ops::BitOr for SubmitFlagBits {
20081    type Output = Self;
20082    #[inline]
20083    fn bitor(self, rhs: Self) -> Self {
20084        Self(self.0 | rhs.0)
20085    }
20086}
20087impl core::ops::BitOrAssign for SubmitFlagBits {
20088    #[inline]
20089    fn bitor_assign(&mut self, rhs: Self) {
20090        self.0 |= rhs.0;
20091    }
20092}
20093impl core::ops::BitAnd for SubmitFlagBits {
20094    type Output = Self;
20095    #[inline]
20096    fn bitand(self, rhs: Self) -> Self {
20097        Self(self.0 & rhs.0)
20098    }
20099}
20100impl core::ops::BitAndAssign for SubmitFlagBits {
20101    #[inline]
20102    fn bitand_assign(&mut self, rhs: Self) {
20103        self.0 &= rhs.0;
20104    }
20105}
20106impl core::ops::BitXor for SubmitFlagBits {
20107    type Output = Self;
20108    #[inline]
20109    fn bitxor(self, rhs: Self) -> Self {
20110        Self(self.0 ^ rhs.0)
20111    }
20112}
20113impl core::ops::BitXorAssign for SubmitFlagBits {
20114    #[inline]
20115    fn bitxor_assign(&mut self, rhs: Self) {
20116        self.0 ^= rhs.0;
20117    }
20118}
20119impl core::ops::Not for SubmitFlagBits {
20120    type Output = Self;
20121    #[inline]
20122    fn not(self) -> Self {
20123        Self(!self.0)
20124    }
20125}
20126impl core::fmt::Debug for SubmitFlagBits {
20127    #[allow(unused_mut, unused_variables)]
20128    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20129        let mut first = true;
20130        let mut remaining = self.0;
20131        if remaining & Self::PROTECTED.0 != 0 {
20132            if !first {
20133                f.write_str(" | ")?;
20134            }
20135            f.write_str("PROTECTED")?;
20136            remaining &= !Self::PROTECTED.0;
20137            first = false;
20138        }
20139        if remaining != 0u32 {
20140            if !first {
20141                f.write_str(" | ")?;
20142            }
20143            write!(f, "{:#x}", remaining)?;
20144        } else if first {
20145            f.write_str("(empty)")?;
20146        }
20147        Ok(())
20148    }
20149}
20150///[`VkSubpassDescriptionFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionFlagBits.html)
20151#[repr(transparent)]
20152#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
20153#[doc(alias = "VkSubpassDescriptionFlagBits")]
20154pub struct SubpassDescriptionFlagBits(u32);
20155impl SubpassDescriptionFlagBits {
20156    #[inline]
20157    pub const fn empty() -> Self {
20158        Self(0u32)
20159    }
20160    #[inline]
20161    pub const fn from_raw(value: u32) -> Self {
20162        Self(value)
20163    }
20164    #[inline]
20165    pub const fn as_raw(self) -> u32 {
20166        self.0
20167    }
20168    #[inline]
20169    pub const fn is_empty(self) -> bool {
20170        self.0 == 0u32
20171    }
20172    #[inline]
20173    pub const fn contains(self, other: Self) -> bool {
20174        (self.0 & other.0) == other.0
20175    }
20176    ///Bit 0.
20177    pub const PER_VIEW_ATTRIBUTES_BIT: Self = Self(1u32);
20178    ///Bit 1.
20179    pub const PER_VIEW_POSITION_X_ONLY_BIT: Self = Self(2u32);
20180    pub const FRAGMENT_REGION_BIT: Self = Self::FRAGMENT_REGION;
20181    pub const SHADER_RESOLVE_BIT: Self = Self::CUSTOM_RESOLVE;
20182    ///Bit 8.
20183    pub const TILE_SHADING_APRON_BIT: Self = Self(256u32);
20184    pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS;
20185    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS;
20186    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT: Self = Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS;
20187    ///Bit 4.
20188    pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS: Self = Self(16u32);
20189    ///Bit 5.
20190    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS: Self = Self(32u32);
20191    ///Bit 6.
20192    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS: Self = Self(64u32);
20193    ///Bit 7.
20194    pub const ENABLE_LEGACY_DITHERING: Self = Self(128u32);
20195    ///Bit 2.
20196    pub const FRAGMENT_REGION: Self = Self(4u32);
20197    ///Bit 3.
20198    pub const CUSTOM_RESOLVE: Self = Self(8u32);
20199}
20200impl core::ops::BitOr for SubpassDescriptionFlagBits {
20201    type Output = Self;
20202    #[inline]
20203    fn bitor(self, rhs: Self) -> Self {
20204        Self(self.0 | rhs.0)
20205    }
20206}
20207impl core::ops::BitOrAssign for SubpassDescriptionFlagBits {
20208    #[inline]
20209    fn bitor_assign(&mut self, rhs: Self) {
20210        self.0 |= rhs.0;
20211    }
20212}
20213impl core::ops::BitAnd for SubpassDescriptionFlagBits {
20214    type Output = Self;
20215    #[inline]
20216    fn bitand(self, rhs: Self) -> Self {
20217        Self(self.0 & rhs.0)
20218    }
20219}
20220impl core::ops::BitAndAssign for SubpassDescriptionFlagBits {
20221    #[inline]
20222    fn bitand_assign(&mut self, rhs: Self) {
20223        self.0 &= rhs.0;
20224    }
20225}
20226impl core::ops::BitXor for SubpassDescriptionFlagBits {
20227    type Output = Self;
20228    #[inline]
20229    fn bitxor(self, rhs: Self) -> Self {
20230        Self(self.0 ^ rhs.0)
20231    }
20232}
20233impl core::ops::BitXorAssign for SubpassDescriptionFlagBits {
20234    #[inline]
20235    fn bitxor_assign(&mut self, rhs: Self) {
20236        self.0 ^= rhs.0;
20237    }
20238}
20239impl core::ops::Not for SubpassDescriptionFlagBits {
20240    type Output = Self;
20241    #[inline]
20242    fn not(self) -> Self {
20243        Self(!self.0)
20244    }
20245}
20246impl core::fmt::Debug for SubpassDescriptionFlagBits {
20247    #[allow(unused_mut, unused_variables)]
20248    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20249        let mut first = true;
20250        let mut remaining = self.0;
20251        if remaining & Self::PER_VIEW_ATTRIBUTES_BIT.0 != 0 {
20252            if !first {
20253                f.write_str(" | ")?;
20254            }
20255            f.write_str("PER_VIEW_ATTRIBUTES_BIT")?;
20256            remaining &= !Self::PER_VIEW_ATTRIBUTES_BIT.0;
20257            first = false;
20258        }
20259        if remaining & Self::PER_VIEW_POSITION_X_ONLY_BIT.0 != 0 {
20260            if !first {
20261                f.write_str(" | ")?;
20262            }
20263            f.write_str("PER_VIEW_POSITION_X_ONLY_BIT")?;
20264            remaining &= !Self::PER_VIEW_POSITION_X_ONLY_BIT.0;
20265            first = false;
20266        }
20267        if remaining & Self::TILE_SHADING_APRON_BIT.0 != 0 {
20268            if !first {
20269                f.write_str(" | ")?;
20270            }
20271            f.write_str("TILE_SHADING_APRON_BIT")?;
20272            remaining &= !Self::TILE_SHADING_APRON_BIT.0;
20273            first = false;
20274        }
20275        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS.0 != 0 {
20276            if !first {
20277                f.write_str(" | ")?;
20278            }
20279            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS")?;
20280            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS.0;
20281            first = false;
20282        }
20283        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS.0 != 0 {
20284            if !first {
20285                f.write_str(" | ")?;
20286            }
20287            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS")?;
20288            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS.0;
20289            first = false;
20290        }
20291        if remaining & Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS.0 != 0 {
20292            if !first {
20293                f.write_str(" | ")?;
20294            }
20295            f.write_str("RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS")?;
20296            remaining &= !Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS.0;
20297            first = false;
20298        }
20299        if remaining & Self::ENABLE_LEGACY_DITHERING.0 != 0 {
20300            if !first {
20301                f.write_str(" | ")?;
20302            }
20303            f.write_str("ENABLE_LEGACY_DITHERING")?;
20304            remaining &= !Self::ENABLE_LEGACY_DITHERING.0;
20305            first = false;
20306        }
20307        if remaining & Self::FRAGMENT_REGION.0 != 0 {
20308            if !first {
20309                f.write_str(" | ")?;
20310            }
20311            f.write_str("FRAGMENT_REGION")?;
20312            remaining &= !Self::FRAGMENT_REGION.0;
20313            first = false;
20314        }
20315        if remaining & Self::CUSTOM_RESOLVE.0 != 0 {
20316            if !first {
20317                f.write_str(" | ")?;
20318            }
20319            f.write_str("CUSTOM_RESOLVE")?;
20320            remaining &= !Self::CUSTOM_RESOLVE.0;
20321            first = false;
20322        }
20323        if remaining != 0u32 {
20324            if !first {
20325                f.write_str(" | ")?;
20326            }
20327            write!(f, "{:#x}", remaining)?;
20328        } else if first {
20329            f.write_str("(empty)")?;
20330        }
20331        Ok(())
20332    }
20333}
20334///[`VkSurfaceCounterFlagBitsEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCounterFlagBitsEXT.html)
20335#[repr(transparent)]
20336#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
20337#[doc(alias = "VkSurfaceCounterFlagBitsEXT")]
20338pub struct SurfaceCounterFlagBitsEXT(u32);
20339impl SurfaceCounterFlagBitsEXT {
20340    #[inline]
20341    pub const fn empty() -> Self {
20342        Self(0u32)
20343    }
20344    #[inline]
20345    pub const fn from_raw(value: u32) -> Self {
20346        Self(value)
20347    }
20348    #[inline]
20349    pub const fn as_raw(self) -> u32 {
20350        self.0
20351    }
20352    #[inline]
20353    pub const fn is_empty(self) -> bool {
20354        self.0 == 0u32
20355    }
20356    #[inline]
20357    pub const fn contains(self, other: Self) -> bool {
20358        (self.0 & other.0) == other.0
20359    }
20360    ///Bit 0.
20361    pub const VBLANK: Self = Self(1u32);
20362}
20363impl core::ops::BitOr for SurfaceCounterFlagBitsEXT {
20364    type Output = Self;
20365    #[inline]
20366    fn bitor(self, rhs: Self) -> Self {
20367        Self(self.0 | rhs.0)
20368    }
20369}
20370impl core::ops::BitOrAssign for SurfaceCounterFlagBitsEXT {
20371    #[inline]
20372    fn bitor_assign(&mut self, rhs: Self) {
20373        self.0 |= rhs.0;
20374    }
20375}
20376impl core::ops::BitAnd for SurfaceCounterFlagBitsEXT {
20377    type Output = Self;
20378    #[inline]
20379    fn bitand(self, rhs: Self) -> Self {
20380        Self(self.0 & rhs.0)
20381    }
20382}
20383impl core::ops::BitAndAssign for SurfaceCounterFlagBitsEXT {
20384    #[inline]
20385    fn bitand_assign(&mut self, rhs: Self) {
20386        self.0 &= rhs.0;
20387    }
20388}
20389impl core::ops::BitXor for SurfaceCounterFlagBitsEXT {
20390    type Output = Self;
20391    #[inline]
20392    fn bitxor(self, rhs: Self) -> Self {
20393        Self(self.0 ^ rhs.0)
20394    }
20395}
20396impl core::ops::BitXorAssign for SurfaceCounterFlagBitsEXT {
20397    #[inline]
20398    fn bitxor_assign(&mut self, rhs: Self) {
20399        self.0 ^= rhs.0;
20400    }
20401}
20402impl core::ops::Not for SurfaceCounterFlagBitsEXT {
20403    type Output = Self;
20404    #[inline]
20405    fn not(self) -> Self {
20406        Self(!self.0)
20407    }
20408}
20409impl core::fmt::Debug for SurfaceCounterFlagBitsEXT {
20410    #[allow(unused_mut, unused_variables)]
20411    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20412        let mut first = true;
20413        let mut remaining = self.0;
20414        if remaining & Self::VBLANK.0 != 0 {
20415            if !first {
20416                f.write_str(" | ")?;
20417            }
20418            f.write_str("VBLANK")?;
20419            remaining &= !Self::VBLANK.0;
20420            first = false;
20421        }
20422        if remaining != 0u32 {
20423            if !first {
20424                f.write_str(" | ")?;
20425            }
20426            write!(f, "{:#x}", remaining)?;
20427        } else if first {
20428            f.write_str("(empty)")?;
20429        }
20430        Ok(())
20431    }
20432}
20433///[`VkSurfaceTransformFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceTransformFlagBitsKHR.html)
20434#[repr(transparent)]
20435#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
20436#[doc(alias = "VkSurfaceTransformFlagBitsKHR")]
20437pub struct SurfaceTransformFlagBitsKHR(u32);
20438impl SurfaceTransformFlagBitsKHR {
20439    #[inline]
20440    pub const fn empty() -> Self {
20441        Self(0u32)
20442    }
20443    #[inline]
20444    pub const fn from_raw(value: u32) -> Self {
20445        Self(value)
20446    }
20447    #[inline]
20448    pub const fn as_raw(self) -> u32 {
20449        self.0
20450    }
20451    #[inline]
20452    pub const fn is_empty(self) -> bool {
20453        self.0 == 0u32
20454    }
20455    #[inline]
20456    pub const fn contains(self, other: Self) -> bool {
20457        (self.0 & other.0) == other.0
20458    }
20459    ///Bit 0.
20460    pub const IDENTITY: Self = Self(1u32);
20461    ///Bit 1.
20462    pub const ROTATE_90: Self = Self(2u32);
20463    ///Bit 2.
20464    pub const ROTATE_180: Self = Self(4u32);
20465    ///Bit 3.
20466    pub const ROTATE_270: Self = Self(8u32);
20467    ///Bit 4.
20468    pub const HORIZONTAL_MIRROR: Self = Self(16u32);
20469    ///Bit 5.
20470    pub const HORIZONTAL_MIRROR_ROTATE_90: Self = Self(32u32);
20471    ///Bit 6.
20472    pub const HORIZONTAL_MIRROR_ROTATE_180: Self = Self(64u32);
20473    ///Bit 7.
20474    pub const HORIZONTAL_MIRROR_ROTATE_270: Self = Self(128u32);
20475    ///Bit 8.
20476    pub const INHERIT: Self = Self(256u32);
20477}
20478impl core::ops::BitOr for SurfaceTransformFlagBitsKHR {
20479    type Output = Self;
20480    #[inline]
20481    fn bitor(self, rhs: Self) -> Self {
20482        Self(self.0 | rhs.0)
20483    }
20484}
20485impl core::ops::BitOrAssign for SurfaceTransformFlagBitsKHR {
20486    #[inline]
20487    fn bitor_assign(&mut self, rhs: Self) {
20488        self.0 |= rhs.0;
20489    }
20490}
20491impl core::ops::BitAnd for SurfaceTransformFlagBitsKHR {
20492    type Output = Self;
20493    #[inline]
20494    fn bitand(self, rhs: Self) -> Self {
20495        Self(self.0 & rhs.0)
20496    }
20497}
20498impl core::ops::BitAndAssign for SurfaceTransformFlagBitsKHR {
20499    #[inline]
20500    fn bitand_assign(&mut self, rhs: Self) {
20501        self.0 &= rhs.0;
20502    }
20503}
20504impl core::ops::BitXor for SurfaceTransformFlagBitsKHR {
20505    type Output = Self;
20506    #[inline]
20507    fn bitxor(self, rhs: Self) -> Self {
20508        Self(self.0 ^ rhs.0)
20509    }
20510}
20511impl core::ops::BitXorAssign for SurfaceTransformFlagBitsKHR {
20512    #[inline]
20513    fn bitxor_assign(&mut self, rhs: Self) {
20514        self.0 ^= rhs.0;
20515    }
20516}
20517impl core::ops::Not for SurfaceTransformFlagBitsKHR {
20518    type Output = Self;
20519    #[inline]
20520    fn not(self) -> Self {
20521        Self(!self.0)
20522    }
20523}
20524impl core::fmt::Debug for SurfaceTransformFlagBitsKHR {
20525    #[allow(unused_mut, unused_variables)]
20526    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20527        let mut first = true;
20528        let mut remaining = self.0;
20529        if remaining & Self::IDENTITY.0 != 0 {
20530            if !first {
20531                f.write_str(" | ")?;
20532            }
20533            f.write_str("IDENTITY")?;
20534            remaining &= !Self::IDENTITY.0;
20535            first = false;
20536        }
20537        if remaining & Self::ROTATE_90.0 != 0 {
20538            if !first {
20539                f.write_str(" | ")?;
20540            }
20541            f.write_str("ROTATE_90")?;
20542            remaining &= !Self::ROTATE_90.0;
20543            first = false;
20544        }
20545        if remaining & Self::ROTATE_180.0 != 0 {
20546            if !first {
20547                f.write_str(" | ")?;
20548            }
20549            f.write_str("ROTATE_180")?;
20550            remaining &= !Self::ROTATE_180.0;
20551            first = false;
20552        }
20553        if remaining & Self::ROTATE_270.0 != 0 {
20554            if !first {
20555                f.write_str(" | ")?;
20556            }
20557            f.write_str("ROTATE_270")?;
20558            remaining &= !Self::ROTATE_270.0;
20559            first = false;
20560        }
20561        if remaining & Self::HORIZONTAL_MIRROR.0 != 0 {
20562            if !first {
20563                f.write_str(" | ")?;
20564            }
20565            f.write_str("HORIZONTAL_MIRROR")?;
20566            remaining &= !Self::HORIZONTAL_MIRROR.0;
20567            first = false;
20568        }
20569        if remaining & Self::HORIZONTAL_MIRROR_ROTATE_90.0 != 0 {
20570            if !first {
20571                f.write_str(" | ")?;
20572            }
20573            f.write_str("HORIZONTAL_MIRROR_ROTATE_90")?;
20574            remaining &= !Self::HORIZONTAL_MIRROR_ROTATE_90.0;
20575            first = false;
20576        }
20577        if remaining & Self::HORIZONTAL_MIRROR_ROTATE_180.0 != 0 {
20578            if !first {
20579                f.write_str(" | ")?;
20580            }
20581            f.write_str("HORIZONTAL_MIRROR_ROTATE_180")?;
20582            remaining &= !Self::HORIZONTAL_MIRROR_ROTATE_180.0;
20583            first = false;
20584        }
20585        if remaining & Self::HORIZONTAL_MIRROR_ROTATE_270.0 != 0 {
20586            if !first {
20587                f.write_str(" | ")?;
20588            }
20589            f.write_str("HORIZONTAL_MIRROR_ROTATE_270")?;
20590            remaining &= !Self::HORIZONTAL_MIRROR_ROTATE_270.0;
20591            first = false;
20592        }
20593        if remaining & Self::INHERIT.0 != 0 {
20594            if !first {
20595                f.write_str(" | ")?;
20596            }
20597            f.write_str("INHERIT")?;
20598            remaining &= !Self::INHERIT.0;
20599            first = false;
20600        }
20601        if remaining != 0u32 {
20602            if !first {
20603                f.write_str(" | ")?;
20604            }
20605            write!(f, "{:#x}", remaining)?;
20606        } else if first {
20607            f.write_str("(empty)")?;
20608        }
20609        Ok(())
20610    }
20611}
20612///[`VkSwapchainCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCreateFlagBitsKHR.html)
20613#[repr(transparent)]
20614#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
20615#[doc(alias = "VkSwapchainCreateFlagBitsKHR")]
20616pub struct SwapchainCreateFlagBitsKHR(u32);
20617impl SwapchainCreateFlagBitsKHR {
20618    #[inline]
20619    pub const fn empty() -> Self {
20620        Self(0u32)
20621    }
20622    #[inline]
20623    pub const fn from_raw(value: u32) -> Self {
20624        Self(value)
20625    }
20626    #[inline]
20627    pub const fn as_raw(self) -> u32 {
20628        self.0
20629    }
20630    #[inline]
20631    pub const fn is_empty(self) -> bool {
20632        self.0 == 0u32
20633    }
20634    #[inline]
20635    pub const fn contains(self, other: Self) -> bool {
20636        (self.0 & other.0) == other.0
20637    }
20638    ///Bit 0.
20639    pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(1u32);
20640    ///Bit 1.
20641    pub const PROTECTED: Self = Self(2u32);
20642    ///Bit 2.
20643    pub const MUTABLE_FORMAT: Self = Self(4u32);
20644    ///Bit 9.
20645    pub const PRESENT_TIMING: Self = Self(512u32);
20646    ///Bit 6.
20647    pub const PRESENT_ID_2: Self = Self(64u32);
20648    ///Bit 7.
20649    pub const PRESENT_WAIT_2: Self = Self(128u32);
20650}
20651impl core::ops::BitOr for SwapchainCreateFlagBitsKHR {
20652    type Output = Self;
20653    #[inline]
20654    fn bitor(self, rhs: Self) -> Self {
20655        Self(self.0 | rhs.0)
20656    }
20657}
20658impl core::ops::BitOrAssign for SwapchainCreateFlagBitsKHR {
20659    #[inline]
20660    fn bitor_assign(&mut self, rhs: Self) {
20661        self.0 |= rhs.0;
20662    }
20663}
20664impl core::ops::BitAnd for SwapchainCreateFlagBitsKHR {
20665    type Output = Self;
20666    #[inline]
20667    fn bitand(self, rhs: Self) -> Self {
20668        Self(self.0 & rhs.0)
20669    }
20670}
20671impl core::ops::BitAndAssign for SwapchainCreateFlagBitsKHR {
20672    #[inline]
20673    fn bitand_assign(&mut self, rhs: Self) {
20674        self.0 &= rhs.0;
20675    }
20676}
20677impl core::ops::BitXor for SwapchainCreateFlagBitsKHR {
20678    type Output = Self;
20679    #[inline]
20680    fn bitxor(self, rhs: Self) -> Self {
20681        Self(self.0 ^ rhs.0)
20682    }
20683}
20684impl core::ops::BitXorAssign for SwapchainCreateFlagBitsKHR {
20685    #[inline]
20686    fn bitxor_assign(&mut self, rhs: Self) {
20687        self.0 ^= rhs.0;
20688    }
20689}
20690impl core::ops::Not for SwapchainCreateFlagBitsKHR {
20691    type Output = Self;
20692    #[inline]
20693    fn not(self) -> Self {
20694        Self(!self.0)
20695    }
20696}
20697impl core::fmt::Debug for SwapchainCreateFlagBitsKHR {
20698    #[allow(unused_mut, unused_variables)]
20699    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20700        let mut first = true;
20701        let mut remaining = self.0;
20702        if remaining & Self::SPLIT_INSTANCE_BIND_REGIONS.0 != 0 {
20703            if !first {
20704                f.write_str(" | ")?;
20705            }
20706            f.write_str("SPLIT_INSTANCE_BIND_REGIONS")?;
20707            remaining &= !Self::SPLIT_INSTANCE_BIND_REGIONS.0;
20708            first = false;
20709        }
20710        if remaining & Self::PROTECTED.0 != 0 {
20711            if !first {
20712                f.write_str(" | ")?;
20713            }
20714            f.write_str("PROTECTED")?;
20715            remaining &= !Self::PROTECTED.0;
20716            first = false;
20717        }
20718        if remaining & Self::MUTABLE_FORMAT.0 != 0 {
20719            if !first {
20720                f.write_str(" | ")?;
20721            }
20722            f.write_str("MUTABLE_FORMAT")?;
20723            remaining &= !Self::MUTABLE_FORMAT.0;
20724            first = false;
20725        }
20726        if remaining & Self::PRESENT_TIMING.0 != 0 {
20727            if !first {
20728                f.write_str(" | ")?;
20729            }
20730            f.write_str("PRESENT_TIMING")?;
20731            remaining &= !Self::PRESENT_TIMING.0;
20732            first = false;
20733        }
20734        if remaining & Self::PRESENT_ID_2.0 != 0 {
20735            if !first {
20736                f.write_str(" | ")?;
20737            }
20738            f.write_str("PRESENT_ID_2")?;
20739            remaining &= !Self::PRESENT_ID_2.0;
20740            first = false;
20741        }
20742        if remaining & Self::PRESENT_WAIT_2.0 != 0 {
20743            if !first {
20744                f.write_str(" | ")?;
20745            }
20746            f.write_str("PRESENT_WAIT_2")?;
20747            remaining &= !Self::PRESENT_WAIT_2.0;
20748            first = false;
20749        }
20750        if remaining != 0u32 {
20751            if !first {
20752                f.write_str(" | ")?;
20753            }
20754            write!(f, "{:#x}", remaining)?;
20755        } else if first {
20756            f.write_str("(empty)")?;
20757        }
20758        Ok(())
20759    }
20760}
20761///[`VkSwapchainImageUsageFlagBitsANDROID`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainImageUsageFlagBitsANDROID.html)
20762#[repr(transparent)]
20763#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
20764#[doc(alias = "VkSwapchainImageUsageFlagBitsANDROID")]
20765pub struct SwapchainImageUsageFlagBitsANDROID(u32);
20766impl SwapchainImageUsageFlagBitsANDROID {
20767    #[inline]
20768    pub const fn empty() -> Self {
20769        Self(0u32)
20770    }
20771    #[inline]
20772    pub const fn from_raw(value: u32) -> Self {
20773        Self(value)
20774    }
20775    #[inline]
20776    pub const fn as_raw(self) -> u32 {
20777        self.0
20778    }
20779    #[inline]
20780    pub const fn is_empty(self) -> bool {
20781        self.0 == 0u32
20782    }
20783    #[inline]
20784    pub const fn contains(self, other: Self) -> bool {
20785        (self.0 & other.0) == other.0
20786    }
20787    ///Bit 0.
20788    pub const SHARED_BIT: Self = Self(1u32);
20789}
20790impl core::ops::BitOr for SwapchainImageUsageFlagBitsANDROID {
20791    type Output = Self;
20792    #[inline]
20793    fn bitor(self, rhs: Self) -> Self {
20794        Self(self.0 | rhs.0)
20795    }
20796}
20797impl core::ops::BitOrAssign for SwapchainImageUsageFlagBitsANDROID {
20798    #[inline]
20799    fn bitor_assign(&mut self, rhs: Self) {
20800        self.0 |= rhs.0;
20801    }
20802}
20803impl core::ops::BitAnd for SwapchainImageUsageFlagBitsANDROID {
20804    type Output = Self;
20805    #[inline]
20806    fn bitand(self, rhs: Self) -> Self {
20807        Self(self.0 & rhs.0)
20808    }
20809}
20810impl core::ops::BitAndAssign for SwapchainImageUsageFlagBitsANDROID {
20811    #[inline]
20812    fn bitand_assign(&mut self, rhs: Self) {
20813        self.0 &= rhs.0;
20814    }
20815}
20816impl core::ops::BitXor for SwapchainImageUsageFlagBitsANDROID {
20817    type Output = Self;
20818    #[inline]
20819    fn bitxor(self, rhs: Self) -> Self {
20820        Self(self.0 ^ rhs.0)
20821    }
20822}
20823impl core::ops::BitXorAssign for SwapchainImageUsageFlagBitsANDROID {
20824    #[inline]
20825    fn bitxor_assign(&mut self, rhs: Self) {
20826        self.0 ^= rhs.0;
20827    }
20828}
20829impl core::ops::Not for SwapchainImageUsageFlagBitsANDROID {
20830    type Output = Self;
20831    #[inline]
20832    fn not(self) -> Self {
20833        Self(!self.0)
20834    }
20835}
20836impl core::fmt::Debug for SwapchainImageUsageFlagBitsANDROID {
20837    #[allow(unused_mut, unused_variables)]
20838    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20839        let mut first = true;
20840        let mut remaining = self.0;
20841        if remaining & Self::SHARED_BIT.0 != 0 {
20842            if !first {
20843                f.write_str(" | ")?;
20844            }
20845            f.write_str("SHARED_BIT")?;
20846            remaining &= !Self::SHARED_BIT.0;
20847            first = false;
20848        }
20849        if remaining != 0u32 {
20850            if !first {
20851                f.write_str(" | ")?;
20852            }
20853            write!(f, "{:#x}", remaining)?;
20854        } else if first {
20855            f.write_str("(empty)")?;
20856        }
20857        Ok(())
20858    }
20859}
20860///[`VkSwapchainImageUsageFlagBitsOHOS`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainImageUsageFlagBitsOHOS.html)
20861#[repr(transparent)]
20862#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
20863#[doc(alias = "VkSwapchainImageUsageFlagBitsOHOS")]
20864pub struct SwapchainImageUsageFlagBitsOHOS(u32);
20865impl SwapchainImageUsageFlagBitsOHOS {
20866    #[inline]
20867    pub const fn empty() -> Self {
20868        Self(0u32)
20869    }
20870    #[inline]
20871    pub const fn from_raw(value: u32) -> Self {
20872        Self(value)
20873    }
20874    #[inline]
20875    pub const fn as_raw(self) -> u32 {
20876        self.0
20877    }
20878    #[inline]
20879    pub const fn is_empty(self) -> bool {
20880        self.0 == 0u32
20881    }
20882    #[inline]
20883    pub const fn contains(self, other: Self) -> bool {
20884        (self.0 & other.0) == other.0
20885    }
20886    ///Bit 0.
20887    pub const SHARED_BIT: Self = Self(1u32);
20888}
20889impl core::ops::BitOr for SwapchainImageUsageFlagBitsOHOS {
20890    type Output = Self;
20891    #[inline]
20892    fn bitor(self, rhs: Self) -> Self {
20893        Self(self.0 | rhs.0)
20894    }
20895}
20896impl core::ops::BitOrAssign for SwapchainImageUsageFlagBitsOHOS {
20897    #[inline]
20898    fn bitor_assign(&mut self, rhs: Self) {
20899        self.0 |= rhs.0;
20900    }
20901}
20902impl core::ops::BitAnd for SwapchainImageUsageFlagBitsOHOS {
20903    type Output = Self;
20904    #[inline]
20905    fn bitand(self, rhs: Self) -> Self {
20906        Self(self.0 & rhs.0)
20907    }
20908}
20909impl core::ops::BitAndAssign for SwapchainImageUsageFlagBitsOHOS {
20910    #[inline]
20911    fn bitand_assign(&mut self, rhs: Self) {
20912        self.0 &= rhs.0;
20913    }
20914}
20915impl core::ops::BitXor for SwapchainImageUsageFlagBitsOHOS {
20916    type Output = Self;
20917    #[inline]
20918    fn bitxor(self, rhs: Self) -> Self {
20919        Self(self.0 ^ rhs.0)
20920    }
20921}
20922impl core::ops::BitXorAssign for SwapchainImageUsageFlagBitsOHOS {
20923    #[inline]
20924    fn bitxor_assign(&mut self, rhs: Self) {
20925        self.0 ^= rhs.0;
20926    }
20927}
20928impl core::ops::Not for SwapchainImageUsageFlagBitsOHOS {
20929    type Output = Self;
20930    #[inline]
20931    fn not(self) -> Self {
20932        Self(!self.0)
20933    }
20934}
20935impl core::fmt::Debug for SwapchainImageUsageFlagBitsOHOS {
20936    #[allow(unused_mut, unused_variables)]
20937    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
20938        let mut first = true;
20939        let mut remaining = self.0;
20940        if remaining & Self::SHARED_BIT.0 != 0 {
20941            if !first {
20942                f.write_str(" | ")?;
20943            }
20944            f.write_str("SHARED_BIT")?;
20945            remaining &= !Self::SHARED_BIT.0;
20946            first = false;
20947        }
20948        if remaining != 0u32 {
20949            if !first {
20950                f.write_str(" | ")?;
20951            }
20952            write!(f, "{:#x}", remaining)?;
20953        } else if first {
20954            f.write_str("(empty)")?;
20955        }
20956        Ok(())
20957    }
20958}
20959///[`VkTensorCreateFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCreateFlagBitsARM.html)
20960#[repr(transparent)]
20961#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
20962#[doc(alias = "VkTensorCreateFlagBitsARM")]
20963pub struct TensorCreateFlagBitsARM(u64);
20964impl TensorCreateFlagBitsARM {
20965    #[inline]
20966    pub const fn empty() -> Self {
20967        Self(0u64)
20968    }
20969    #[inline]
20970    pub const fn from_raw(value: u64) -> Self {
20971        Self(value)
20972    }
20973    #[inline]
20974    pub const fn as_raw(self) -> u64 {
20975        self.0
20976    }
20977    #[inline]
20978    pub const fn is_empty(self) -> bool {
20979        self.0 == 0u64
20980    }
20981    #[inline]
20982    pub const fn contains(self, other: Self) -> bool {
20983        (self.0 & other.0) == other.0
20984    }
20985    ///Bit 0.
20986    pub const MUTABLE_FORMAT_BIT: Self = Self(1u64);
20987    ///Bit 1.
20988    pub const PROTECTED_BIT: Self = Self(2u64);
20989    ///Bit 3.
20990    pub const DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT: Self = Self(8u64);
20991    ///Bit 2.
20992    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT: Self = Self(4u64);
20993}
20994impl core::ops::BitOr for TensorCreateFlagBitsARM {
20995    type Output = Self;
20996    #[inline]
20997    fn bitor(self, rhs: Self) -> Self {
20998        Self(self.0 | rhs.0)
20999    }
21000}
21001impl core::ops::BitOrAssign for TensorCreateFlagBitsARM {
21002    #[inline]
21003    fn bitor_assign(&mut self, rhs: Self) {
21004        self.0 |= rhs.0;
21005    }
21006}
21007impl core::ops::BitAnd for TensorCreateFlagBitsARM {
21008    type Output = Self;
21009    #[inline]
21010    fn bitand(self, rhs: Self) -> Self {
21011        Self(self.0 & rhs.0)
21012    }
21013}
21014impl core::ops::BitAndAssign for TensorCreateFlagBitsARM {
21015    #[inline]
21016    fn bitand_assign(&mut self, rhs: Self) {
21017        self.0 &= rhs.0;
21018    }
21019}
21020impl core::ops::BitXor for TensorCreateFlagBitsARM {
21021    type Output = Self;
21022    #[inline]
21023    fn bitxor(self, rhs: Self) -> Self {
21024        Self(self.0 ^ rhs.0)
21025    }
21026}
21027impl core::ops::BitXorAssign for TensorCreateFlagBitsARM {
21028    #[inline]
21029    fn bitxor_assign(&mut self, rhs: Self) {
21030        self.0 ^= rhs.0;
21031    }
21032}
21033impl core::ops::Not for TensorCreateFlagBitsARM {
21034    type Output = Self;
21035    #[inline]
21036    fn not(self) -> Self {
21037        Self(!self.0)
21038    }
21039}
21040impl core::fmt::Debug for TensorCreateFlagBitsARM {
21041    #[allow(unused_mut, unused_variables)]
21042    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21043        let mut first = true;
21044        let mut remaining = self.0;
21045        if remaining & Self::MUTABLE_FORMAT_BIT.0 != 0 {
21046            if !first {
21047                f.write_str(" | ")?;
21048            }
21049            f.write_str("MUTABLE_FORMAT_BIT")?;
21050            remaining &= !Self::MUTABLE_FORMAT_BIT.0;
21051            first = false;
21052        }
21053        if remaining & Self::PROTECTED_BIT.0 != 0 {
21054            if !first {
21055                f.write_str(" | ")?;
21056            }
21057            f.write_str("PROTECTED_BIT")?;
21058            remaining &= !Self::PROTECTED_BIT.0;
21059            first = false;
21060        }
21061        if remaining & Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT.0 != 0 {
21062            if !first {
21063                f.write_str(" | ")?;
21064            }
21065            f.write_str("DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT")?;
21066            remaining &= !Self::DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT.0;
21067            first = false;
21068        }
21069        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT.0 != 0 {
21070            if !first {
21071                f.write_str(" | ")?;
21072            }
21073            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT")?;
21074            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT.0;
21075            first = false;
21076        }
21077        if remaining != 0u64 {
21078            if !first {
21079                f.write_str(" | ")?;
21080            }
21081            write!(f, "{:#x}", remaining)?;
21082        } else if first {
21083            f.write_str("(empty)")?;
21084        }
21085        Ok(())
21086    }
21087}
21088///[`VkTensorUsageFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorUsageFlagBitsARM.html)
21089#[repr(transparent)]
21090#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
21091#[doc(alias = "VkTensorUsageFlagBitsARM")]
21092pub struct TensorUsageFlagBitsARM(u64);
21093impl TensorUsageFlagBitsARM {
21094    #[inline]
21095    pub const fn empty() -> Self {
21096        Self(0u64)
21097    }
21098    #[inline]
21099    pub const fn from_raw(value: u64) -> Self {
21100        Self(value)
21101    }
21102    #[inline]
21103    pub const fn as_raw(self) -> u64 {
21104        self.0
21105    }
21106    #[inline]
21107    pub const fn is_empty(self) -> bool {
21108        self.0 == 0u64
21109    }
21110    #[inline]
21111    pub const fn contains(self, other: Self) -> bool {
21112        (self.0 & other.0) == other.0
21113    }
21114    ///Bit 1.
21115    pub const SHADER_BIT: Self = Self(2u64);
21116    ///Bit 2.
21117    pub const TRANSFER_SRC_BIT: Self = Self(4u64);
21118    ///Bit 3.
21119    pub const TRANSFER_DST_BIT: Self = Self(8u64);
21120    ///Bit 4.
21121    pub const IMAGE_ALIASING_BIT: Self = Self(16u64);
21122    ///Bit 5.
21123    pub const DATA_GRAPH_BIT: Self = Self(32u64);
21124}
21125impl core::ops::BitOr for TensorUsageFlagBitsARM {
21126    type Output = Self;
21127    #[inline]
21128    fn bitor(self, rhs: Self) -> Self {
21129        Self(self.0 | rhs.0)
21130    }
21131}
21132impl core::ops::BitOrAssign for TensorUsageFlagBitsARM {
21133    #[inline]
21134    fn bitor_assign(&mut self, rhs: Self) {
21135        self.0 |= rhs.0;
21136    }
21137}
21138impl core::ops::BitAnd for TensorUsageFlagBitsARM {
21139    type Output = Self;
21140    #[inline]
21141    fn bitand(self, rhs: Self) -> Self {
21142        Self(self.0 & rhs.0)
21143    }
21144}
21145impl core::ops::BitAndAssign for TensorUsageFlagBitsARM {
21146    #[inline]
21147    fn bitand_assign(&mut self, rhs: Self) {
21148        self.0 &= rhs.0;
21149    }
21150}
21151impl core::ops::BitXor for TensorUsageFlagBitsARM {
21152    type Output = Self;
21153    #[inline]
21154    fn bitxor(self, rhs: Self) -> Self {
21155        Self(self.0 ^ rhs.0)
21156    }
21157}
21158impl core::ops::BitXorAssign for TensorUsageFlagBitsARM {
21159    #[inline]
21160    fn bitxor_assign(&mut self, rhs: Self) {
21161        self.0 ^= rhs.0;
21162    }
21163}
21164impl core::ops::Not for TensorUsageFlagBitsARM {
21165    type Output = Self;
21166    #[inline]
21167    fn not(self) -> Self {
21168        Self(!self.0)
21169    }
21170}
21171impl core::fmt::Debug for TensorUsageFlagBitsARM {
21172    #[allow(unused_mut, unused_variables)]
21173    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21174        let mut first = true;
21175        let mut remaining = self.0;
21176        if remaining & Self::SHADER_BIT.0 != 0 {
21177            if !first {
21178                f.write_str(" | ")?;
21179            }
21180            f.write_str("SHADER_BIT")?;
21181            remaining &= !Self::SHADER_BIT.0;
21182            first = false;
21183        }
21184        if remaining & Self::TRANSFER_SRC_BIT.0 != 0 {
21185            if !first {
21186                f.write_str(" | ")?;
21187            }
21188            f.write_str("TRANSFER_SRC_BIT")?;
21189            remaining &= !Self::TRANSFER_SRC_BIT.0;
21190            first = false;
21191        }
21192        if remaining & Self::TRANSFER_DST_BIT.0 != 0 {
21193            if !first {
21194                f.write_str(" | ")?;
21195            }
21196            f.write_str("TRANSFER_DST_BIT")?;
21197            remaining &= !Self::TRANSFER_DST_BIT.0;
21198            first = false;
21199        }
21200        if remaining & Self::IMAGE_ALIASING_BIT.0 != 0 {
21201            if !first {
21202                f.write_str(" | ")?;
21203            }
21204            f.write_str("IMAGE_ALIASING_BIT")?;
21205            remaining &= !Self::IMAGE_ALIASING_BIT.0;
21206            first = false;
21207        }
21208        if remaining & Self::DATA_GRAPH_BIT.0 != 0 {
21209            if !first {
21210                f.write_str(" | ")?;
21211            }
21212            f.write_str("DATA_GRAPH_BIT")?;
21213            remaining &= !Self::DATA_GRAPH_BIT.0;
21214            first = false;
21215        }
21216        if remaining != 0u64 {
21217            if !first {
21218                f.write_str(" | ")?;
21219            }
21220            write!(f, "{:#x}", remaining)?;
21221        } else if first {
21222            f.write_str("(empty)")?;
21223        }
21224        Ok(())
21225    }
21226}
21227///[`VkTensorViewCreateFlagBitsARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagBitsARM.html)
21228#[repr(transparent)]
21229#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
21230#[doc(alias = "VkTensorViewCreateFlagBitsARM")]
21231pub struct TensorViewCreateFlagBitsARM(u64);
21232impl TensorViewCreateFlagBitsARM {
21233    #[inline]
21234    pub const fn empty() -> Self {
21235        Self(0u64)
21236    }
21237    #[inline]
21238    pub const fn from_raw(value: u64) -> Self {
21239        Self(value)
21240    }
21241    #[inline]
21242    pub const fn as_raw(self) -> u64 {
21243        self.0
21244    }
21245    #[inline]
21246    pub const fn is_empty(self) -> bool {
21247        self.0 == 0u64
21248    }
21249    #[inline]
21250    pub const fn contains(self, other: Self) -> bool {
21251        (self.0 & other.0) == other.0
21252    }
21253    ///Bit 0.
21254    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT: Self = Self(1u64);
21255}
21256impl core::ops::BitOr for TensorViewCreateFlagBitsARM {
21257    type Output = Self;
21258    #[inline]
21259    fn bitor(self, rhs: Self) -> Self {
21260        Self(self.0 | rhs.0)
21261    }
21262}
21263impl core::ops::BitOrAssign for TensorViewCreateFlagBitsARM {
21264    #[inline]
21265    fn bitor_assign(&mut self, rhs: Self) {
21266        self.0 |= rhs.0;
21267    }
21268}
21269impl core::ops::BitAnd for TensorViewCreateFlagBitsARM {
21270    type Output = Self;
21271    #[inline]
21272    fn bitand(self, rhs: Self) -> Self {
21273        Self(self.0 & rhs.0)
21274    }
21275}
21276impl core::ops::BitAndAssign for TensorViewCreateFlagBitsARM {
21277    #[inline]
21278    fn bitand_assign(&mut self, rhs: Self) {
21279        self.0 &= rhs.0;
21280    }
21281}
21282impl core::ops::BitXor for TensorViewCreateFlagBitsARM {
21283    type Output = Self;
21284    #[inline]
21285    fn bitxor(self, rhs: Self) -> Self {
21286        Self(self.0 ^ rhs.0)
21287    }
21288}
21289impl core::ops::BitXorAssign for TensorViewCreateFlagBitsARM {
21290    #[inline]
21291    fn bitxor_assign(&mut self, rhs: Self) {
21292        self.0 ^= rhs.0;
21293    }
21294}
21295impl core::ops::Not for TensorViewCreateFlagBitsARM {
21296    type Output = Self;
21297    #[inline]
21298    fn not(self) -> Self {
21299        Self(!self.0)
21300    }
21301}
21302impl core::fmt::Debug for TensorViewCreateFlagBitsARM {
21303    #[allow(unused_mut, unused_variables)]
21304    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21305        let mut first = true;
21306        let mut remaining = self.0;
21307        if remaining & Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT.0 != 0 {
21308            if !first {
21309                f.write_str(" | ")?;
21310            }
21311            f.write_str("DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT")?;
21312            remaining &= !Self::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT.0;
21313            first = false;
21314        }
21315        if remaining != 0u64 {
21316            if !first {
21317                f.write_str(" | ")?;
21318            }
21319            write!(f, "{:#x}", remaining)?;
21320        } else if first {
21321            f.write_str("(empty)")?;
21322        }
21323        Ok(())
21324    }
21325}
21326///[`VkTileShadingRenderPassFlagBitsQCOM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagBitsQCOM.html)
21327#[repr(transparent)]
21328#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
21329#[doc(alias = "VkTileShadingRenderPassFlagBitsQCOM")]
21330pub struct TileShadingRenderPassFlagBitsQCOM(u32);
21331impl TileShadingRenderPassFlagBitsQCOM {
21332    #[inline]
21333    pub const fn empty() -> Self {
21334        Self(0u32)
21335    }
21336    #[inline]
21337    pub const fn from_raw(value: u32) -> Self {
21338        Self(value)
21339    }
21340    #[inline]
21341    pub const fn as_raw(self) -> u32 {
21342        self.0
21343    }
21344    #[inline]
21345    pub const fn is_empty(self) -> bool {
21346        self.0 == 0u32
21347    }
21348    #[inline]
21349    pub const fn contains(self, other: Self) -> bool {
21350        (self.0 & other.0) == other.0
21351    }
21352    ///Bit 0.
21353    pub const ENABLE_BIT: Self = Self(1u32);
21354    ///Bit 1.
21355    pub const PER_TILE_EXECUTION_BIT: Self = Self(2u32);
21356}
21357impl core::ops::BitOr for TileShadingRenderPassFlagBitsQCOM {
21358    type Output = Self;
21359    #[inline]
21360    fn bitor(self, rhs: Self) -> Self {
21361        Self(self.0 | rhs.0)
21362    }
21363}
21364impl core::ops::BitOrAssign for TileShadingRenderPassFlagBitsQCOM {
21365    #[inline]
21366    fn bitor_assign(&mut self, rhs: Self) {
21367        self.0 |= rhs.0;
21368    }
21369}
21370impl core::ops::BitAnd for TileShadingRenderPassFlagBitsQCOM {
21371    type Output = Self;
21372    #[inline]
21373    fn bitand(self, rhs: Self) -> Self {
21374        Self(self.0 & rhs.0)
21375    }
21376}
21377impl core::ops::BitAndAssign for TileShadingRenderPassFlagBitsQCOM {
21378    #[inline]
21379    fn bitand_assign(&mut self, rhs: Self) {
21380        self.0 &= rhs.0;
21381    }
21382}
21383impl core::ops::BitXor for TileShadingRenderPassFlagBitsQCOM {
21384    type Output = Self;
21385    #[inline]
21386    fn bitxor(self, rhs: Self) -> Self {
21387        Self(self.0 ^ rhs.0)
21388    }
21389}
21390impl core::ops::BitXorAssign for TileShadingRenderPassFlagBitsQCOM {
21391    #[inline]
21392    fn bitxor_assign(&mut self, rhs: Self) {
21393        self.0 ^= rhs.0;
21394    }
21395}
21396impl core::ops::Not for TileShadingRenderPassFlagBitsQCOM {
21397    type Output = Self;
21398    #[inline]
21399    fn not(self) -> Self {
21400        Self(!self.0)
21401    }
21402}
21403impl core::fmt::Debug for TileShadingRenderPassFlagBitsQCOM {
21404    #[allow(unused_mut, unused_variables)]
21405    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21406        let mut first = true;
21407        let mut remaining = self.0;
21408        if remaining & Self::ENABLE_BIT.0 != 0 {
21409            if !first {
21410                f.write_str(" | ")?;
21411            }
21412            f.write_str("ENABLE_BIT")?;
21413            remaining &= !Self::ENABLE_BIT.0;
21414            first = false;
21415        }
21416        if remaining & Self::PER_TILE_EXECUTION_BIT.0 != 0 {
21417            if !first {
21418                f.write_str(" | ")?;
21419            }
21420            f.write_str("PER_TILE_EXECUTION_BIT")?;
21421            remaining &= !Self::PER_TILE_EXECUTION_BIT.0;
21422            first = false;
21423        }
21424        if remaining != 0u32 {
21425            if !first {
21426                f.write_str(" | ")?;
21427            }
21428            write!(f, "{:#x}", remaining)?;
21429        } else if first {
21430            f.write_str("(empty)")?;
21431        }
21432        Ok(())
21433    }
21434}
21435///[`VkToolPurposeFlagBits`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkToolPurposeFlagBits.html)
21436#[repr(transparent)]
21437#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
21438#[doc(alias = "VkToolPurposeFlagBits")]
21439pub struct ToolPurposeFlagBits(u32);
21440impl ToolPurposeFlagBits {
21441    #[inline]
21442    pub const fn empty() -> Self {
21443        Self(0u32)
21444    }
21445    #[inline]
21446    pub const fn from_raw(value: u32) -> Self {
21447        Self(value)
21448    }
21449    #[inline]
21450    pub const fn as_raw(self) -> u32 {
21451        self.0
21452    }
21453    #[inline]
21454    pub const fn is_empty(self) -> bool {
21455        self.0 == 0u32
21456    }
21457    #[inline]
21458    pub const fn contains(self, other: Self) -> bool {
21459        (self.0 & other.0) == other.0
21460    }
21461    ///Bit 0.
21462    pub const VALIDATION: Self = Self(1u32);
21463    ///Bit 1.
21464    pub const PROFILING: Self = Self(2u32);
21465    ///Bit 2.
21466    pub const TRACING: Self = Self(4u32);
21467    ///Bit 3.
21468    pub const ADDITIONAL_FEATURES: Self = Self(8u32);
21469    ///Bit 4.
21470    pub const MODIFYING_FEATURES: Self = Self(16u32);
21471    ///Bit 5.
21472    pub const DEBUG_REPORTING: Self = Self(32u32);
21473    ///Bit 6.
21474    pub const DEBUG_MARKERS: Self = Self(64u32);
21475}
21476impl core::ops::BitOr for ToolPurposeFlagBits {
21477    type Output = Self;
21478    #[inline]
21479    fn bitor(self, rhs: Self) -> Self {
21480        Self(self.0 | rhs.0)
21481    }
21482}
21483impl core::ops::BitOrAssign for ToolPurposeFlagBits {
21484    #[inline]
21485    fn bitor_assign(&mut self, rhs: Self) {
21486        self.0 |= rhs.0;
21487    }
21488}
21489impl core::ops::BitAnd for ToolPurposeFlagBits {
21490    type Output = Self;
21491    #[inline]
21492    fn bitand(self, rhs: Self) -> Self {
21493        Self(self.0 & rhs.0)
21494    }
21495}
21496impl core::ops::BitAndAssign for ToolPurposeFlagBits {
21497    #[inline]
21498    fn bitand_assign(&mut self, rhs: Self) {
21499        self.0 &= rhs.0;
21500    }
21501}
21502impl core::ops::BitXor for ToolPurposeFlagBits {
21503    type Output = Self;
21504    #[inline]
21505    fn bitxor(self, rhs: Self) -> Self {
21506        Self(self.0 ^ rhs.0)
21507    }
21508}
21509impl core::ops::BitXorAssign for ToolPurposeFlagBits {
21510    #[inline]
21511    fn bitxor_assign(&mut self, rhs: Self) {
21512        self.0 ^= rhs.0;
21513    }
21514}
21515impl core::ops::Not for ToolPurposeFlagBits {
21516    type Output = Self;
21517    #[inline]
21518    fn not(self) -> Self {
21519        Self(!self.0)
21520    }
21521}
21522impl core::fmt::Debug for ToolPurposeFlagBits {
21523    #[allow(unused_mut, unused_variables)]
21524    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21525        let mut first = true;
21526        let mut remaining = self.0;
21527        if remaining & Self::VALIDATION.0 != 0 {
21528            if !first {
21529                f.write_str(" | ")?;
21530            }
21531            f.write_str("VALIDATION")?;
21532            remaining &= !Self::VALIDATION.0;
21533            first = false;
21534        }
21535        if remaining & Self::PROFILING.0 != 0 {
21536            if !first {
21537                f.write_str(" | ")?;
21538            }
21539            f.write_str("PROFILING")?;
21540            remaining &= !Self::PROFILING.0;
21541            first = false;
21542        }
21543        if remaining & Self::TRACING.0 != 0 {
21544            if !first {
21545                f.write_str(" | ")?;
21546            }
21547            f.write_str("TRACING")?;
21548            remaining &= !Self::TRACING.0;
21549            first = false;
21550        }
21551        if remaining & Self::ADDITIONAL_FEATURES.0 != 0 {
21552            if !first {
21553                f.write_str(" | ")?;
21554            }
21555            f.write_str("ADDITIONAL_FEATURES")?;
21556            remaining &= !Self::ADDITIONAL_FEATURES.0;
21557            first = false;
21558        }
21559        if remaining & Self::MODIFYING_FEATURES.0 != 0 {
21560            if !first {
21561                f.write_str(" | ")?;
21562            }
21563            f.write_str("MODIFYING_FEATURES")?;
21564            remaining &= !Self::MODIFYING_FEATURES.0;
21565            first = false;
21566        }
21567        if remaining & Self::DEBUG_REPORTING.0 != 0 {
21568            if !first {
21569                f.write_str(" | ")?;
21570            }
21571            f.write_str("DEBUG_REPORTING")?;
21572            remaining &= !Self::DEBUG_REPORTING.0;
21573            first = false;
21574        }
21575        if remaining & Self::DEBUG_MARKERS.0 != 0 {
21576            if !first {
21577                f.write_str(" | ")?;
21578            }
21579            f.write_str("DEBUG_MARKERS")?;
21580            remaining &= !Self::DEBUG_MARKERS.0;
21581            first = false;
21582        }
21583        if remaining != 0u32 {
21584            if !first {
21585                f.write_str(" | ")?;
21586            }
21587            write!(f, "{:#x}", remaining)?;
21588        } else if first {
21589            f.write_str("(empty)")?;
21590        }
21591        Ok(())
21592    }
21593}
21594///[`VkVideoCapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCapabilityFlagBitsKHR.html)
21595#[repr(transparent)]
21596#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
21597#[doc(alias = "VkVideoCapabilityFlagBitsKHR")]
21598pub struct VideoCapabilityFlagBitsKHR(u32);
21599impl VideoCapabilityFlagBitsKHR {
21600    #[inline]
21601    pub const fn empty() -> Self {
21602        Self(0u32)
21603    }
21604    #[inline]
21605    pub const fn from_raw(value: u32) -> Self {
21606        Self(value)
21607    }
21608    #[inline]
21609    pub const fn as_raw(self) -> u32 {
21610        self.0
21611    }
21612    #[inline]
21613    pub const fn is_empty(self) -> bool {
21614        self.0 == 0u32
21615    }
21616    #[inline]
21617    pub const fn contains(self, other: Self) -> bool {
21618        (self.0 & other.0) == other.0
21619    }
21620    ///Bit 0.
21621    pub const PROTECTED_CONTENT: Self = Self(1u32);
21622    ///Bit 1.
21623    pub const SEPARATE_REFERENCE_IMAGES: Self = Self(2u32);
21624}
21625impl core::ops::BitOr for VideoCapabilityFlagBitsKHR {
21626    type Output = Self;
21627    #[inline]
21628    fn bitor(self, rhs: Self) -> Self {
21629        Self(self.0 | rhs.0)
21630    }
21631}
21632impl core::ops::BitOrAssign for VideoCapabilityFlagBitsKHR {
21633    #[inline]
21634    fn bitor_assign(&mut self, rhs: Self) {
21635        self.0 |= rhs.0;
21636    }
21637}
21638impl core::ops::BitAnd for VideoCapabilityFlagBitsKHR {
21639    type Output = Self;
21640    #[inline]
21641    fn bitand(self, rhs: Self) -> Self {
21642        Self(self.0 & rhs.0)
21643    }
21644}
21645impl core::ops::BitAndAssign for VideoCapabilityFlagBitsKHR {
21646    #[inline]
21647    fn bitand_assign(&mut self, rhs: Self) {
21648        self.0 &= rhs.0;
21649    }
21650}
21651impl core::ops::BitXor for VideoCapabilityFlagBitsKHR {
21652    type Output = Self;
21653    #[inline]
21654    fn bitxor(self, rhs: Self) -> Self {
21655        Self(self.0 ^ rhs.0)
21656    }
21657}
21658impl core::ops::BitXorAssign for VideoCapabilityFlagBitsKHR {
21659    #[inline]
21660    fn bitxor_assign(&mut self, rhs: Self) {
21661        self.0 ^= rhs.0;
21662    }
21663}
21664impl core::ops::Not for VideoCapabilityFlagBitsKHR {
21665    type Output = Self;
21666    #[inline]
21667    fn not(self) -> Self {
21668        Self(!self.0)
21669    }
21670}
21671impl core::fmt::Debug for VideoCapabilityFlagBitsKHR {
21672    #[allow(unused_mut, unused_variables)]
21673    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21674        let mut first = true;
21675        let mut remaining = self.0;
21676        if remaining & Self::PROTECTED_CONTENT.0 != 0 {
21677            if !first {
21678                f.write_str(" | ")?;
21679            }
21680            f.write_str("PROTECTED_CONTENT")?;
21681            remaining &= !Self::PROTECTED_CONTENT.0;
21682            first = false;
21683        }
21684        if remaining & Self::SEPARATE_REFERENCE_IMAGES.0 != 0 {
21685            if !first {
21686                f.write_str(" | ")?;
21687            }
21688            f.write_str("SEPARATE_REFERENCE_IMAGES")?;
21689            remaining &= !Self::SEPARATE_REFERENCE_IMAGES.0;
21690            first = false;
21691        }
21692        if remaining != 0u32 {
21693            if !first {
21694                f.write_str(" | ")?;
21695            }
21696            write!(f, "{:#x}", remaining)?;
21697        } else if first {
21698            f.write_str("(empty)")?;
21699        }
21700        Ok(())
21701    }
21702}
21703///[`VkVideoChromaSubsamplingFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html)
21704#[repr(transparent)]
21705#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
21706#[doc(alias = "VkVideoChromaSubsamplingFlagBitsKHR")]
21707pub struct VideoChromaSubsamplingFlagBitsKHR(u32);
21708impl VideoChromaSubsamplingFlagBitsKHR {
21709    #[inline]
21710    pub const fn empty() -> Self {
21711        Self(0u32)
21712    }
21713    #[inline]
21714    pub const fn from_raw(value: u32) -> Self {
21715        Self(value)
21716    }
21717    #[inline]
21718    pub const fn as_raw(self) -> u32 {
21719        self.0
21720    }
21721    #[inline]
21722    pub const fn is_empty(self) -> bool {
21723        self.0 == 0u32
21724    }
21725    #[inline]
21726    pub const fn contains(self, other: Self) -> bool {
21727        (self.0 & other.0) == other.0
21728    }
21729    pub const INVALID: Self = Self(0u32);
21730    ///Bit 0.
21731    pub const MONOCHROME: Self = Self(1u32);
21732    ///Bit 1.
21733    pub const _420: Self = Self(2u32);
21734    ///Bit 2.
21735    pub const _422: Self = Self(4u32);
21736    ///Bit 3.
21737    pub const _444: Self = Self(8u32);
21738}
21739impl core::ops::BitOr for VideoChromaSubsamplingFlagBitsKHR {
21740    type Output = Self;
21741    #[inline]
21742    fn bitor(self, rhs: Self) -> Self {
21743        Self(self.0 | rhs.0)
21744    }
21745}
21746impl core::ops::BitOrAssign for VideoChromaSubsamplingFlagBitsKHR {
21747    #[inline]
21748    fn bitor_assign(&mut self, rhs: Self) {
21749        self.0 |= rhs.0;
21750    }
21751}
21752impl core::ops::BitAnd for VideoChromaSubsamplingFlagBitsKHR {
21753    type Output = Self;
21754    #[inline]
21755    fn bitand(self, rhs: Self) -> Self {
21756        Self(self.0 & rhs.0)
21757    }
21758}
21759impl core::ops::BitAndAssign for VideoChromaSubsamplingFlagBitsKHR {
21760    #[inline]
21761    fn bitand_assign(&mut self, rhs: Self) {
21762        self.0 &= rhs.0;
21763    }
21764}
21765impl core::ops::BitXor for VideoChromaSubsamplingFlagBitsKHR {
21766    type Output = Self;
21767    #[inline]
21768    fn bitxor(self, rhs: Self) -> Self {
21769        Self(self.0 ^ rhs.0)
21770    }
21771}
21772impl core::ops::BitXorAssign for VideoChromaSubsamplingFlagBitsKHR {
21773    #[inline]
21774    fn bitxor_assign(&mut self, rhs: Self) {
21775        self.0 ^= rhs.0;
21776    }
21777}
21778impl core::ops::Not for VideoChromaSubsamplingFlagBitsKHR {
21779    type Output = Self;
21780    #[inline]
21781    fn not(self) -> Self {
21782        Self(!self.0)
21783    }
21784}
21785impl core::fmt::Debug for VideoChromaSubsamplingFlagBitsKHR {
21786    #[allow(unused_mut, unused_variables)]
21787    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21788        let mut first = true;
21789        let mut remaining = self.0;
21790        if remaining & Self::MONOCHROME.0 != 0 {
21791            if !first {
21792                f.write_str(" | ")?;
21793            }
21794            f.write_str("MONOCHROME")?;
21795            remaining &= !Self::MONOCHROME.0;
21796            first = false;
21797        }
21798        if remaining & Self::_420.0 != 0 {
21799            if !first {
21800                f.write_str(" | ")?;
21801            }
21802            f.write_str("_420")?;
21803            remaining &= !Self::_420.0;
21804            first = false;
21805        }
21806        if remaining & Self::_422.0 != 0 {
21807            if !first {
21808                f.write_str(" | ")?;
21809            }
21810            f.write_str("_422")?;
21811            remaining &= !Self::_422.0;
21812            first = false;
21813        }
21814        if remaining & Self::_444.0 != 0 {
21815            if !first {
21816                f.write_str(" | ")?;
21817            }
21818            f.write_str("_444")?;
21819            remaining &= !Self::_444.0;
21820            first = false;
21821        }
21822        if remaining != 0u32 {
21823            if !first {
21824                f.write_str(" | ")?;
21825            }
21826            write!(f, "{:#x}", remaining)?;
21827        } else if first {
21828            f.write_str("(empty)")?;
21829        }
21830        Ok(())
21831    }
21832}
21833///[`VkVideoCodecOperationFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodecOperationFlagBitsKHR.html)
21834#[repr(transparent)]
21835#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
21836#[doc(alias = "VkVideoCodecOperationFlagBitsKHR")]
21837pub struct VideoCodecOperationFlagBitsKHR(u32);
21838impl VideoCodecOperationFlagBitsKHR {
21839    #[inline]
21840    pub const fn empty() -> Self {
21841        Self(0u32)
21842    }
21843    #[inline]
21844    pub const fn from_raw(value: u32) -> Self {
21845        Self(value)
21846    }
21847    #[inline]
21848    pub const fn as_raw(self) -> u32 {
21849        self.0
21850    }
21851    #[inline]
21852    pub const fn is_empty(self) -> bool {
21853        self.0 == 0u32
21854    }
21855    #[inline]
21856    pub const fn contains(self, other: Self) -> bool {
21857        (self.0 & other.0) == other.0
21858    }
21859    pub const NONE: Self = Self(0u32);
21860    ///Bit 16.
21861    pub const ENCODE_H264: Self = Self(65536u32);
21862    ///Bit 17.
21863    pub const ENCODE_H265: Self = Self(131072u32);
21864    ///Bit 0.
21865    pub const DECODE_H264: Self = Self(1u32);
21866    ///Bit 1.
21867    pub const DECODE_H265: Self = Self(2u32);
21868    ///Bit 2.
21869    pub const DECODE_AV1: Self = Self(4u32);
21870    ///Bit 18.
21871    pub const ENCODE_AV1: Self = Self(262144u32);
21872    ///Bit 3.
21873    pub const DECODE_VP9: Self = Self(8u32);
21874}
21875impl core::ops::BitOr for VideoCodecOperationFlagBitsKHR {
21876    type Output = Self;
21877    #[inline]
21878    fn bitor(self, rhs: Self) -> Self {
21879        Self(self.0 | rhs.0)
21880    }
21881}
21882impl core::ops::BitOrAssign for VideoCodecOperationFlagBitsKHR {
21883    #[inline]
21884    fn bitor_assign(&mut self, rhs: Self) {
21885        self.0 |= rhs.0;
21886    }
21887}
21888impl core::ops::BitAnd for VideoCodecOperationFlagBitsKHR {
21889    type Output = Self;
21890    #[inline]
21891    fn bitand(self, rhs: Self) -> Self {
21892        Self(self.0 & rhs.0)
21893    }
21894}
21895impl core::ops::BitAndAssign for VideoCodecOperationFlagBitsKHR {
21896    #[inline]
21897    fn bitand_assign(&mut self, rhs: Self) {
21898        self.0 &= rhs.0;
21899    }
21900}
21901impl core::ops::BitXor for VideoCodecOperationFlagBitsKHR {
21902    type Output = Self;
21903    #[inline]
21904    fn bitxor(self, rhs: Self) -> Self {
21905        Self(self.0 ^ rhs.0)
21906    }
21907}
21908impl core::ops::BitXorAssign for VideoCodecOperationFlagBitsKHR {
21909    #[inline]
21910    fn bitxor_assign(&mut self, rhs: Self) {
21911        self.0 ^= rhs.0;
21912    }
21913}
21914impl core::ops::Not for VideoCodecOperationFlagBitsKHR {
21915    type Output = Self;
21916    #[inline]
21917    fn not(self) -> Self {
21918        Self(!self.0)
21919    }
21920}
21921impl core::fmt::Debug for VideoCodecOperationFlagBitsKHR {
21922    #[allow(unused_mut, unused_variables)]
21923    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21924        let mut first = true;
21925        let mut remaining = self.0;
21926        if remaining & Self::ENCODE_H264.0 != 0 {
21927            if !first {
21928                f.write_str(" | ")?;
21929            }
21930            f.write_str("ENCODE_H264")?;
21931            remaining &= !Self::ENCODE_H264.0;
21932            first = false;
21933        }
21934        if remaining & Self::ENCODE_H265.0 != 0 {
21935            if !first {
21936                f.write_str(" | ")?;
21937            }
21938            f.write_str("ENCODE_H265")?;
21939            remaining &= !Self::ENCODE_H265.0;
21940            first = false;
21941        }
21942        if remaining & Self::DECODE_H264.0 != 0 {
21943            if !first {
21944                f.write_str(" | ")?;
21945            }
21946            f.write_str("DECODE_H264")?;
21947            remaining &= !Self::DECODE_H264.0;
21948            first = false;
21949        }
21950        if remaining & Self::DECODE_H265.0 != 0 {
21951            if !first {
21952                f.write_str(" | ")?;
21953            }
21954            f.write_str("DECODE_H265")?;
21955            remaining &= !Self::DECODE_H265.0;
21956            first = false;
21957        }
21958        if remaining & Self::DECODE_AV1.0 != 0 {
21959            if !first {
21960                f.write_str(" | ")?;
21961            }
21962            f.write_str("DECODE_AV1")?;
21963            remaining &= !Self::DECODE_AV1.0;
21964            first = false;
21965        }
21966        if remaining & Self::ENCODE_AV1.0 != 0 {
21967            if !first {
21968                f.write_str(" | ")?;
21969            }
21970            f.write_str("ENCODE_AV1")?;
21971            remaining &= !Self::ENCODE_AV1.0;
21972            first = false;
21973        }
21974        if remaining & Self::DECODE_VP9.0 != 0 {
21975            if !first {
21976                f.write_str(" | ")?;
21977            }
21978            f.write_str("DECODE_VP9")?;
21979            remaining &= !Self::DECODE_VP9.0;
21980            first = false;
21981        }
21982        if remaining != 0u32 {
21983            if !first {
21984                f.write_str(" | ")?;
21985            }
21986            write!(f, "{:#x}", remaining)?;
21987        } else if first {
21988            f.write_str("(empty)")?;
21989        }
21990        Ok(())
21991    }
21992}
21993///[`VkVideoCodingControlFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodingControlFlagBitsKHR.html)
21994#[repr(transparent)]
21995#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
21996#[doc(alias = "VkVideoCodingControlFlagBitsKHR")]
21997pub struct VideoCodingControlFlagBitsKHR(u32);
21998impl VideoCodingControlFlagBitsKHR {
21999    #[inline]
22000    pub const fn empty() -> Self {
22001        Self(0u32)
22002    }
22003    #[inline]
22004    pub const fn from_raw(value: u32) -> Self {
22005        Self(value)
22006    }
22007    #[inline]
22008    pub const fn as_raw(self) -> u32 {
22009        self.0
22010    }
22011    #[inline]
22012    pub const fn is_empty(self) -> bool {
22013        self.0 == 0u32
22014    }
22015    #[inline]
22016    pub const fn contains(self, other: Self) -> bool {
22017        (self.0 & other.0) == other.0
22018    }
22019    ///Bit 0.
22020    pub const RESET: Self = Self(1u32);
22021    ///Bit 1.
22022    pub const ENCODE_RATE_CONTROL: Self = Self(2u32);
22023    ///Bit 2.
22024    pub const ENCODE_QUALITY_LEVEL: Self = Self(4u32);
22025}
22026impl core::ops::BitOr for VideoCodingControlFlagBitsKHR {
22027    type Output = Self;
22028    #[inline]
22029    fn bitor(self, rhs: Self) -> Self {
22030        Self(self.0 | rhs.0)
22031    }
22032}
22033impl core::ops::BitOrAssign for VideoCodingControlFlagBitsKHR {
22034    #[inline]
22035    fn bitor_assign(&mut self, rhs: Self) {
22036        self.0 |= rhs.0;
22037    }
22038}
22039impl core::ops::BitAnd for VideoCodingControlFlagBitsKHR {
22040    type Output = Self;
22041    #[inline]
22042    fn bitand(self, rhs: Self) -> Self {
22043        Self(self.0 & rhs.0)
22044    }
22045}
22046impl core::ops::BitAndAssign for VideoCodingControlFlagBitsKHR {
22047    #[inline]
22048    fn bitand_assign(&mut self, rhs: Self) {
22049        self.0 &= rhs.0;
22050    }
22051}
22052impl core::ops::BitXor for VideoCodingControlFlagBitsKHR {
22053    type Output = Self;
22054    #[inline]
22055    fn bitxor(self, rhs: Self) -> Self {
22056        Self(self.0 ^ rhs.0)
22057    }
22058}
22059impl core::ops::BitXorAssign for VideoCodingControlFlagBitsKHR {
22060    #[inline]
22061    fn bitxor_assign(&mut self, rhs: Self) {
22062        self.0 ^= rhs.0;
22063    }
22064}
22065impl core::ops::Not for VideoCodingControlFlagBitsKHR {
22066    type Output = Self;
22067    #[inline]
22068    fn not(self) -> Self {
22069        Self(!self.0)
22070    }
22071}
22072impl core::fmt::Debug for VideoCodingControlFlagBitsKHR {
22073    #[allow(unused_mut, unused_variables)]
22074    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22075        let mut first = true;
22076        let mut remaining = self.0;
22077        if remaining & Self::RESET.0 != 0 {
22078            if !first {
22079                f.write_str(" | ")?;
22080            }
22081            f.write_str("RESET")?;
22082            remaining &= !Self::RESET.0;
22083            first = false;
22084        }
22085        if remaining & Self::ENCODE_RATE_CONTROL.0 != 0 {
22086            if !first {
22087                f.write_str(" | ")?;
22088            }
22089            f.write_str("ENCODE_RATE_CONTROL")?;
22090            remaining &= !Self::ENCODE_RATE_CONTROL.0;
22091            first = false;
22092        }
22093        if remaining & Self::ENCODE_QUALITY_LEVEL.0 != 0 {
22094            if !first {
22095                f.write_str(" | ")?;
22096            }
22097            f.write_str("ENCODE_QUALITY_LEVEL")?;
22098            remaining &= !Self::ENCODE_QUALITY_LEVEL.0;
22099            first = false;
22100        }
22101        if remaining != 0u32 {
22102            if !first {
22103                f.write_str(" | ")?;
22104            }
22105            write!(f, "{:#x}", remaining)?;
22106        } else if first {
22107            f.write_str("(empty)")?;
22108        }
22109        Ok(())
22110    }
22111}
22112///[`VkVideoComponentBitDepthFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoComponentBitDepthFlagBitsKHR.html)
22113#[repr(transparent)]
22114#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
22115#[doc(alias = "VkVideoComponentBitDepthFlagBitsKHR")]
22116pub struct VideoComponentBitDepthFlagBitsKHR(u32);
22117impl VideoComponentBitDepthFlagBitsKHR {
22118    #[inline]
22119    pub const fn empty() -> Self {
22120        Self(0u32)
22121    }
22122    #[inline]
22123    pub const fn from_raw(value: u32) -> Self {
22124        Self(value)
22125    }
22126    #[inline]
22127    pub const fn as_raw(self) -> u32 {
22128        self.0
22129    }
22130    #[inline]
22131    pub const fn is_empty(self) -> bool {
22132        self.0 == 0u32
22133    }
22134    #[inline]
22135    pub const fn contains(self, other: Self) -> bool {
22136        (self.0 & other.0) == other.0
22137    }
22138    pub const INVALID: Self = Self(0u32);
22139    ///Bit 0.
22140    pub const _8: Self = Self(1u32);
22141    ///Bit 2.
22142    pub const _10: Self = Self(4u32);
22143    ///Bit 4.
22144    pub const _12: Self = Self(16u32);
22145}
22146impl core::ops::BitOr for VideoComponentBitDepthFlagBitsKHR {
22147    type Output = Self;
22148    #[inline]
22149    fn bitor(self, rhs: Self) -> Self {
22150        Self(self.0 | rhs.0)
22151    }
22152}
22153impl core::ops::BitOrAssign for VideoComponentBitDepthFlagBitsKHR {
22154    #[inline]
22155    fn bitor_assign(&mut self, rhs: Self) {
22156        self.0 |= rhs.0;
22157    }
22158}
22159impl core::ops::BitAnd for VideoComponentBitDepthFlagBitsKHR {
22160    type Output = Self;
22161    #[inline]
22162    fn bitand(self, rhs: Self) -> Self {
22163        Self(self.0 & rhs.0)
22164    }
22165}
22166impl core::ops::BitAndAssign for VideoComponentBitDepthFlagBitsKHR {
22167    #[inline]
22168    fn bitand_assign(&mut self, rhs: Self) {
22169        self.0 &= rhs.0;
22170    }
22171}
22172impl core::ops::BitXor for VideoComponentBitDepthFlagBitsKHR {
22173    type Output = Self;
22174    #[inline]
22175    fn bitxor(self, rhs: Self) -> Self {
22176        Self(self.0 ^ rhs.0)
22177    }
22178}
22179impl core::ops::BitXorAssign for VideoComponentBitDepthFlagBitsKHR {
22180    #[inline]
22181    fn bitxor_assign(&mut self, rhs: Self) {
22182        self.0 ^= rhs.0;
22183    }
22184}
22185impl core::ops::Not for VideoComponentBitDepthFlagBitsKHR {
22186    type Output = Self;
22187    #[inline]
22188    fn not(self) -> Self {
22189        Self(!self.0)
22190    }
22191}
22192impl core::fmt::Debug for VideoComponentBitDepthFlagBitsKHR {
22193    #[allow(unused_mut, unused_variables)]
22194    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22195        let mut first = true;
22196        let mut remaining = self.0;
22197        if remaining & Self::_8.0 != 0 {
22198            if !first {
22199                f.write_str(" | ")?;
22200            }
22201            f.write_str("_8")?;
22202            remaining &= !Self::_8.0;
22203            first = false;
22204        }
22205        if remaining & Self::_10.0 != 0 {
22206            if !first {
22207                f.write_str(" | ")?;
22208            }
22209            f.write_str("_10")?;
22210            remaining &= !Self::_10.0;
22211            first = false;
22212        }
22213        if remaining & Self::_12.0 != 0 {
22214            if !first {
22215                f.write_str(" | ")?;
22216            }
22217            f.write_str("_12")?;
22218            remaining &= !Self::_12.0;
22219            first = false;
22220        }
22221        if remaining != 0u32 {
22222            if !first {
22223                f.write_str(" | ")?;
22224            }
22225            write!(f, "{:#x}", remaining)?;
22226        } else if first {
22227            f.write_str("(empty)")?;
22228        }
22229        Ok(())
22230    }
22231}
22232///[`VkVideoDecodeCapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeCapabilityFlagBitsKHR.html)
22233#[repr(transparent)]
22234#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
22235#[doc(alias = "VkVideoDecodeCapabilityFlagBitsKHR")]
22236pub struct VideoDecodeCapabilityFlagBitsKHR(u32);
22237impl VideoDecodeCapabilityFlagBitsKHR {
22238    #[inline]
22239    pub const fn empty() -> Self {
22240        Self(0u32)
22241    }
22242    #[inline]
22243    pub const fn from_raw(value: u32) -> Self {
22244        Self(value)
22245    }
22246    #[inline]
22247    pub const fn as_raw(self) -> u32 {
22248        self.0
22249    }
22250    #[inline]
22251    pub const fn is_empty(self) -> bool {
22252        self.0 == 0u32
22253    }
22254    #[inline]
22255    pub const fn contains(self, other: Self) -> bool {
22256        (self.0 & other.0) == other.0
22257    }
22258    ///Bit 0.
22259    pub const DPB_AND_OUTPUT_COINCIDE: Self = Self(1u32);
22260    ///Bit 1.
22261    pub const DPB_AND_OUTPUT_DISTINCT: Self = Self(2u32);
22262}
22263impl core::ops::BitOr for VideoDecodeCapabilityFlagBitsKHR {
22264    type Output = Self;
22265    #[inline]
22266    fn bitor(self, rhs: Self) -> Self {
22267        Self(self.0 | rhs.0)
22268    }
22269}
22270impl core::ops::BitOrAssign for VideoDecodeCapabilityFlagBitsKHR {
22271    #[inline]
22272    fn bitor_assign(&mut self, rhs: Self) {
22273        self.0 |= rhs.0;
22274    }
22275}
22276impl core::ops::BitAnd for VideoDecodeCapabilityFlagBitsKHR {
22277    type Output = Self;
22278    #[inline]
22279    fn bitand(self, rhs: Self) -> Self {
22280        Self(self.0 & rhs.0)
22281    }
22282}
22283impl core::ops::BitAndAssign for VideoDecodeCapabilityFlagBitsKHR {
22284    #[inline]
22285    fn bitand_assign(&mut self, rhs: Self) {
22286        self.0 &= rhs.0;
22287    }
22288}
22289impl core::ops::BitXor for VideoDecodeCapabilityFlagBitsKHR {
22290    type Output = Self;
22291    #[inline]
22292    fn bitxor(self, rhs: Self) -> Self {
22293        Self(self.0 ^ rhs.0)
22294    }
22295}
22296impl core::ops::BitXorAssign for VideoDecodeCapabilityFlagBitsKHR {
22297    #[inline]
22298    fn bitxor_assign(&mut self, rhs: Self) {
22299        self.0 ^= rhs.0;
22300    }
22301}
22302impl core::ops::Not for VideoDecodeCapabilityFlagBitsKHR {
22303    type Output = Self;
22304    #[inline]
22305    fn not(self) -> Self {
22306        Self(!self.0)
22307    }
22308}
22309impl core::fmt::Debug for VideoDecodeCapabilityFlagBitsKHR {
22310    #[allow(unused_mut, unused_variables)]
22311    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22312        let mut first = true;
22313        let mut remaining = self.0;
22314        if remaining & Self::DPB_AND_OUTPUT_COINCIDE.0 != 0 {
22315            if !first {
22316                f.write_str(" | ")?;
22317            }
22318            f.write_str("DPB_AND_OUTPUT_COINCIDE")?;
22319            remaining &= !Self::DPB_AND_OUTPUT_COINCIDE.0;
22320            first = false;
22321        }
22322        if remaining & Self::DPB_AND_OUTPUT_DISTINCT.0 != 0 {
22323            if !first {
22324                f.write_str(" | ")?;
22325            }
22326            f.write_str("DPB_AND_OUTPUT_DISTINCT")?;
22327            remaining &= !Self::DPB_AND_OUTPUT_DISTINCT.0;
22328            first = false;
22329        }
22330        if remaining != 0u32 {
22331            if !first {
22332                f.write_str(" | ")?;
22333            }
22334            write!(f, "{:#x}", remaining)?;
22335        } else if first {
22336            f.write_str("(empty)")?;
22337        }
22338        Ok(())
22339    }
22340}
22341///[`VkVideoDecodeH264PictureLayoutFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureLayoutFlagBitsKHR.html)
22342#[repr(transparent)]
22343#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
22344#[doc(alias = "VkVideoDecodeH264PictureLayoutFlagBitsKHR")]
22345pub struct VideoDecodeH264PictureLayoutFlagBitsKHR(u32);
22346impl VideoDecodeH264PictureLayoutFlagBitsKHR {
22347    #[inline]
22348    pub const fn empty() -> Self {
22349        Self(0u32)
22350    }
22351    #[inline]
22352    pub const fn from_raw(value: u32) -> Self {
22353        Self(value)
22354    }
22355    #[inline]
22356    pub const fn as_raw(self) -> u32 {
22357        self.0
22358    }
22359    #[inline]
22360    pub const fn is_empty(self) -> bool {
22361        self.0 == 0u32
22362    }
22363    #[inline]
22364    pub const fn contains(self, other: Self) -> bool {
22365        (self.0 & other.0) == other.0
22366    }
22367    pub const PROGRESSIVE: Self = Self(0u32);
22368    ///Bit 0.
22369    pub const INTERLACED_INTERLEAVED_LINES: Self = Self(1u32);
22370    ///Bit 1.
22371    pub const INTERLACED_SEPARATE_PLANES: Self = Self(2u32);
22372}
22373impl core::ops::BitOr for VideoDecodeH264PictureLayoutFlagBitsKHR {
22374    type Output = Self;
22375    #[inline]
22376    fn bitor(self, rhs: Self) -> Self {
22377        Self(self.0 | rhs.0)
22378    }
22379}
22380impl core::ops::BitOrAssign for VideoDecodeH264PictureLayoutFlagBitsKHR {
22381    #[inline]
22382    fn bitor_assign(&mut self, rhs: Self) {
22383        self.0 |= rhs.0;
22384    }
22385}
22386impl core::ops::BitAnd for VideoDecodeH264PictureLayoutFlagBitsKHR {
22387    type Output = Self;
22388    #[inline]
22389    fn bitand(self, rhs: Self) -> Self {
22390        Self(self.0 & rhs.0)
22391    }
22392}
22393impl core::ops::BitAndAssign for VideoDecodeH264PictureLayoutFlagBitsKHR {
22394    #[inline]
22395    fn bitand_assign(&mut self, rhs: Self) {
22396        self.0 &= rhs.0;
22397    }
22398}
22399impl core::ops::BitXor for VideoDecodeH264PictureLayoutFlagBitsKHR {
22400    type Output = Self;
22401    #[inline]
22402    fn bitxor(self, rhs: Self) -> Self {
22403        Self(self.0 ^ rhs.0)
22404    }
22405}
22406impl core::ops::BitXorAssign for VideoDecodeH264PictureLayoutFlagBitsKHR {
22407    #[inline]
22408    fn bitxor_assign(&mut self, rhs: Self) {
22409        self.0 ^= rhs.0;
22410    }
22411}
22412impl core::ops::Not for VideoDecodeH264PictureLayoutFlagBitsKHR {
22413    type Output = Self;
22414    #[inline]
22415    fn not(self) -> Self {
22416        Self(!self.0)
22417    }
22418}
22419impl core::fmt::Debug for VideoDecodeH264PictureLayoutFlagBitsKHR {
22420    #[allow(unused_mut, unused_variables)]
22421    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22422        let mut first = true;
22423        let mut remaining = self.0;
22424        if remaining & Self::INTERLACED_INTERLEAVED_LINES.0 != 0 {
22425            if !first {
22426                f.write_str(" | ")?;
22427            }
22428            f.write_str("INTERLACED_INTERLEAVED_LINES")?;
22429            remaining &= !Self::INTERLACED_INTERLEAVED_LINES.0;
22430            first = false;
22431        }
22432        if remaining & Self::INTERLACED_SEPARATE_PLANES.0 != 0 {
22433            if !first {
22434                f.write_str(" | ")?;
22435            }
22436            f.write_str("INTERLACED_SEPARATE_PLANES")?;
22437            remaining &= !Self::INTERLACED_SEPARATE_PLANES.0;
22438            first = false;
22439        }
22440        if remaining != 0u32 {
22441            if !first {
22442                f.write_str(" | ")?;
22443            }
22444            write!(f, "{:#x}", remaining)?;
22445        } else if first {
22446            f.write_str("(empty)")?;
22447        }
22448        Ok(())
22449    }
22450}
22451///[`VkVideoDecodeUsageFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeUsageFlagBitsKHR.html)
22452#[repr(transparent)]
22453#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
22454#[doc(alias = "VkVideoDecodeUsageFlagBitsKHR")]
22455pub struct VideoDecodeUsageFlagBitsKHR(u32);
22456impl VideoDecodeUsageFlagBitsKHR {
22457    #[inline]
22458    pub const fn empty() -> Self {
22459        Self(0u32)
22460    }
22461    #[inline]
22462    pub const fn from_raw(value: u32) -> Self {
22463        Self(value)
22464    }
22465    #[inline]
22466    pub const fn as_raw(self) -> u32 {
22467        self.0
22468    }
22469    #[inline]
22470    pub const fn is_empty(self) -> bool {
22471        self.0 == 0u32
22472    }
22473    #[inline]
22474    pub const fn contains(self, other: Self) -> bool {
22475        (self.0 & other.0) == other.0
22476    }
22477    pub const DEFAULT: Self = Self(0u32);
22478    ///Bit 0.
22479    pub const TRANSCODING: Self = Self(1u32);
22480    ///Bit 1.
22481    pub const OFFLINE: Self = Self(2u32);
22482    ///Bit 2.
22483    pub const STREAMING: Self = Self(4u32);
22484}
22485impl core::ops::BitOr for VideoDecodeUsageFlagBitsKHR {
22486    type Output = Self;
22487    #[inline]
22488    fn bitor(self, rhs: Self) -> Self {
22489        Self(self.0 | rhs.0)
22490    }
22491}
22492impl core::ops::BitOrAssign for VideoDecodeUsageFlagBitsKHR {
22493    #[inline]
22494    fn bitor_assign(&mut self, rhs: Self) {
22495        self.0 |= rhs.0;
22496    }
22497}
22498impl core::ops::BitAnd for VideoDecodeUsageFlagBitsKHR {
22499    type Output = Self;
22500    #[inline]
22501    fn bitand(self, rhs: Self) -> Self {
22502        Self(self.0 & rhs.0)
22503    }
22504}
22505impl core::ops::BitAndAssign for VideoDecodeUsageFlagBitsKHR {
22506    #[inline]
22507    fn bitand_assign(&mut self, rhs: Self) {
22508        self.0 &= rhs.0;
22509    }
22510}
22511impl core::ops::BitXor for VideoDecodeUsageFlagBitsKHR {
22512    type Output = Self;
22513    #[inline]
22514    fn bitxor(self, rhs: Self) -> Self {
22515        Self(self.0 ^ rhs.0)
22516    }
22517}
22518impl core::ops::BitXorAssign for VideoDecodeUsageFlagBitsKHR {
22519    #[inline]
22520    fn bitxor_assign(&mut self, rhs: Self) {
22521        self.0 ^= rhs.0;
22522    }
22523}
22524impl core::ops::Not for VideoDecodeUsageFlagBitsKHR {
22525    type Output = Self;
22526    #[inline]
22527    fn not(self) -> Self {
22528        Self(!self.0)
22529    }
22530}
22531impl core::fmt::Debug for VideoDecodeUsageFlagBitsKHR {
22532    #[allow(unused_mut, unused_variables)]
22533    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22534        let mut first = true;
22535        let mut remaining = self.0;
22536        if remaining & Self::TRANSCODING.0 != 0 {
22537            if !first {
22538                f.write_str(" | ")?;
22539            }
22540            f.write_str("TRANSCODING")?;
22541            remaining &= !Self::TRANSCODING.0;
22542            first = false;
22543        }
22544        if remaining & Self::OFFLINE.0 != 0 {
22545            if !first {
22546                f.write_str(" | ")?;
22547            }
22548            f.write_str("OFFLINE")?;
22549            remaining &= !Self::OFFLINE.0;
22550            first = false;
22551        }
22552        if remaining & Self::STREAMING.0 != 0 {
22553            if !first {
22554                f.write_str(" | ")?;
22555            }
22556            f.write_str("STREAMING")?;
22557            remaining &= !Self::STREAMING.0;
22558            first = false;
22559        }
22560        if remaining != 0u32 {
22561            if !first {
22562                f.write_str(" | ")?;
22563            }
22564            write!(f, "{:#x}", remaining)?;
22565        } else if first {
22566            f.write_str("(empty)")?;
22567        }
22568        Ok(())
22569    }
22570}
22571///[`VkVideoEncodeAV1CapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilityFlagBitsKHR.html)
22572#[repr(transparent)]
22573#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
22574#[doc(alias = "VkVideoEncodeAV1CapabilityFlagBitsKHR")]
22575pub struct VideoEncodeAV1CapabilityFlagBitsKHR(u32);
22576impl VideoEncodeAV1CapabilityFlagBitsKHR {
22577    #[inline]
22578    pub const fn empty() -> Self {
22579        Self(0u32)
22580    }
22581    #[inline]
22582    pub const fn from_raw(value: u32) -> Self {
22583        Self(value)
22584    }
22585    #[inline]
22586    pub const fn as_raw(self) -> u32 {
22587        self.0
22588    }
22589    #[inline]
22590    pub const fn is_empty(self) -> bool {
22591        self.0 == 0u32
22592    }
22593    #[inline]
22594    pub const fn contains(self, other: Self) -> bool {
22595        (self.0 & other.0) == other.0
22596    }
22597    ///Bit 0.
22598    pub const PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX: Self = Self(1u32);
22599    ///Bit 1.
22600    pub const GENERATE_OBU_EXTENSION_HEADER: Self = Self(2u32);
22601    ///Bit 2.
22602    pub const PRIMARY_REFERENCE_CDF_ONLY: Self = Self(4u32);
22603    ///Bit 3.
22604    pub const FRAME_SIZE_OVERRIDE: Self = Self(8u32);
22605    ///Bit 4.
22606    pub const MOTION_VECTOR_SCALING: Self = Self(16u32);
22607    ///Bit 5.
22608    pub const COMPOUND_PREDICTION_INTRA_REFRESH: Self = Self(32u32);
22609}
22610impl core::ops::BitOr for VideoEncodeAV1CapabilityFlagBitsKHR {
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 VideoEncodeAV1CapabilityFlagBitsKHR {
22618    #[inline]
22619    fn bitor_assign(&mut self, rhs: Self) {
22620        self.0 |= rhs.0;
22621    }
22622}
22623impl core::ops::BitAnd for VideoEncodeAV1CapabilityFlagBitsKHR {
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 VideoEncodeAV1CapabilityFlagBitsKHR {
22631    #[inline]
22632    fn bitand_assign(&mut self, rhs: Self) {
22633        self.0 &= rhs.0;
22634    }
22635}
22636impl core::ops::BitXor for VideoEncodeAV1CapabilityFlagBitsKHR {
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 VideoEncodeAV1CapabilityFlagBitsKHR {
22644    #[inline]
22645    fn bitxor_assign(&mut self, rhs: Self) {
22646        self.0 ^= rhs.0;
22647    }
22648}
22649impl core::ops::Not for VideoEncodeAV1CapabilityFlagBitsKHR {
22650    type Output = Self;
22651    #[inline]
22652    fn not(self) -> Self {
22653        Self(!self.0)
22654    }
22655}
22656impl core::fmt::Debug for VideoEncodeAV1CapabilityFlagBitsKHR {
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::PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX.0 != 0 {
22662            if !first {
22663                f.write_str(" | ")?;
22664            }
22665            f.write_str("PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX")?;
22666            remaining &= !Self::PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX.0;
22667            first = false;
22668        }
22669        if remaining & Self::GENERATE_OBU_EXTENSION_HEADER.0 != 0 {
22670            if !first {
22671                f.write_str(" | ")?;
22672            }
22673            f.write_str("GENERATE_OBU_EXTENSION_HEADER")?;
22674            remaining &= !Self::GENERATE_OBU_EXTENSION_HEADER.0;
22675            first = false;
22676        }
22677        if remaining & Self::PRIMARY_REFERENCE_CDF_ONLY.0 != 0 {
22678            if !first {
22679                f.write_str(" | ")?;
22680            }
22681            f.write_str("PRIMARY_REFERENCE_CDF_ONLY")?;
22682            remaining &= !Self::PRIMARY_REFERENCE_CDF_ONLY.0;
22683            first = false;
22684        }
22685        if remaining & Self::FRAME_SIZE_OVERRIDE.0 != 0 {
22686            if !first {
22687                f.write_str(" | ")?;
22688            }
22689            f.write_str("FRAME_SIZE_OVERRIDE")?;
22690            remaining &= !Self::FRAME_SIZE_OVERRIDE.0;
22691            first = false;
22692        }
22693        if remaining & Self::MOTION_VECTOR_SCALING.0 != 0 {
22694            if !first {
22695                f.write_str(" | ")?;
22696            }
22697            f.write_str("MOTION_VECTOR_SCALING")?;
22698            remaining &= !Self::MOTION_VECTOR_SCALING.0;
22699            first = false;
22700        }
22701        if remaining & Self::COMPOUND_PREDICTION_INTRA_REFRESH.0 != 0 {
22702            if !first {
22703                f.write_str(" | ")?;
22704            }
22705            f.write_str("COMPOUND_PREDICTION_INTRA_REFRESH")?;
22706            remaining &= !Self::COMPOUND_PREDICTION_INTRA_REFRESH.0;
22707            first = false;
22708        }
22709        if remaining != 0u32 {
22710            if !first {
22711                f.write_str(" | ")?;
22712            }
22713            write!(f, "{:#x}", remaining)?;
22714        } else if first {
22715            f.write_str("(empty)")?;
22716        }
22717        Ok(())
22718    }
22719}
22720///[`VkVideoEncodeAV1RateControlFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlFlagBitsKHR.html)
22721#[repr(transparent)]
22722#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
22723#[doc(alias = "VkVideoEncodeAV1RateControlFlagBitsKHR")]
22724pub struct VideoEncodeAV1RateControlFlagBitsKHR(u32);
22725impl VideoEncodeAV1RateControlFlagBitsKHR {
22726    #[inline]
22727    pub const fn empty() -> Self {
22728        Self(0u32)
22729    }
22730    #[inline]
22731    pub const fn from_raw(value: u32) -> Self {
22732        Self(value)
22733    }
22734    #[inline]
22735    pub const fn as_raw(self) -> u32 {
22736        self.0
22737    }
22738    #[inline]
22739    pub const fn is_empty(self) -> bool {
22740        self.0 == 0u32
22741    }
22742    #[inline]
22743    pub const fn contains(self, other: Self) -> bool {
22744        (self.0 & other.0) == other.0
22745    }
22746    ///Bit 0.
22747    pub const REGULAR_GOP: Self = Self(1u32);
22748    ///Bit 1.
22749    pub const TEMPORAL_LAYER_PATTERN_DYADIC: Self = Self(2u32);
22750    ///Bit 2.
22751    pub const REFERENCE_PATTERN_FLAT: Self = Self(4u32);
22752    ///Bit 3.
22753    pub const REFERENCE_PATTERN_DYADIC: Self = Self(8u32);
22754}
22755impl core::ops::BitOr for VideoEncodeAV1RateControlFlagBitsKHR {
22756    type Output = Self;
22757    #[inline]
22758    fn bitor(self, rhs: Self) -> Self {
22759        Self(self.0 | rhs.0)
22760    }
22761}
22762impl core::ops::BitOrAssign for VideoEncodeAV1RateControlFlagBitsKHR {
22763    #[inline]
22764    fn bitor_assign(&mut self, rhs: Self) {
22765        self.0 |= rhs.0;
22766    }
22767}
22768impl core::ops::BitAnd for VideoEncodeAV1RateControlFlagBitsKHR {
22769    type Output = Self;
22770    #[inline]
22771    fn bitand(self, rhs: Self) -> Self {
22772        Self(self.0 & rhs.0)
22773    }
22774}
22775impl core::ops::BitAndAssign for VideoEncodeAV1RateControlFlagBitsKHR {
22776    #[inline]
22777    fn bitand_assign(&mut self, rhs: Self) {
22778        self.0 &= rhs.0;
22779    }
22780}
22781impl core::ops::BitXor for VideoEncodeAV1RateControlFlagBitsKHR {
22782    type Output = Self;
22783    #[inline]
22784    fn bitxor(self, rhs: Self) -> Self {
22785        Self(self.0 ^ rhs.0)
22786    }
22787}
22788impl core::ops::BitXorAssign for VideoEncodeAV1RateControlFlagBitsKHR {
22789    #[inline]
22790    fn bitxor_assign(&mut self, rhs: Self) {
22791        self.0 ^= rhs.0;
22792    }
22793}
22794impl core::ops::Not for VideoEncodeAV1RateControlFlagBitsKHR {
22795    type Output = Self;
22796    #[inline]
22797    fn not(self) -> Self {
22798        Self(!self.0)
22799    }
22800}
22801impl core::fmt::Debug for VideoEncodeAV1RateControlFlagBitsKHR {
22802    #[allow(unused_mut, unused_variables)]
22803    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22804        let mut first = true;
22805        let mut remaining = self.0;
22806        if remaining & Self::REGULAR_GOP.0 != 0 {
22807            if !first {
22808                f.write_str(" | ")?;
22809            }
22810            f.write_str("REGULAR_GOP")?;
22811            remaining &= !Self::REGULAR_GOP.0;
22812            first = false;
22813        }
22814        if remaining & Self::TEMPORAL_LAYER_PATTERN_DYADIC.0 != 0 {
22815            if !first {
22816                f.write_str(" | ")?;
22817            }
22818            f.write_str("TEMPORAL_LAYER_PATTERN_DYADIC")?;
22819            remaining &= !Self::TEMPORAL_LAYER_PATTERN_DYADIC.0;
22820            first = false;
22821        }
22822        if remaining & Self::REFERENCE_PATTERN_FLAT.0 != 0 {
22823            if !first {
22824                f.write_str(" | ")?;
22825            }
22826            f.write_str("REFERENCE_PATTERN_FLAT")?;
22827            remaining &= !Self::REFERENCE_PATTERN_FLAT.0;
22828            first = false;
22829        }
22830        if remaining & Self::REFERENCE_PATTERN_DYADIC.0 != 0 {
22831            if !first {
22832                f.write_str(" | ")?;
22833            }
22834            f.write_str("REFERENCE_PATTERN_DYADIC")?;
22835            remaining &= !Self::REFERENCE_PATTERN_DYADIC.0;
22836            first = false;
22837        }
22838        if remaining != 0u32 {
22839            if !first {
22840                f.write_str(" | ")?;
22841            }
22842            write!(f, "{:#x}", remaining)?;
22843        } else if first {
22844            f.write_str("(empty)")?;
22845        }
22846        Ok(())
22847    }
22848}
22849///[`VkVideoEncodeAV1StdFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1StdFlagBitsKHR.html)
22850#[repr(transparent)]
22851#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
22852#[doc(alias = "VkVideoEncodeAV1StdFlagBitsKHR")]
22853pub struct VideoEncodeAV1StdFlagBitsKHR(u32);
22854impl VideoEncodeAV1StdFlagBitsKHR {
22855    #[inline]
22856    pub const fn empty() -> Self {
22857        Self(0u32)
22858    }
22859    #[inline]
22860    pub const fn from_raw(value: u32) -> Self {
22861        Self(value)
22862    }
22863    #[inline]
22864    pub const fn as_raw(self) -> u32 {
22865        self.0
22866    }
22867    #[inline]
22868    pub const fn is_empty(self) -> bool {
22869        self.0 == 0u32
22870    }
22871    #[inline]
22872    pub const fn contains(self, other: Self) -> bool {
22873        (self.0 & other.0) == other.0
22874    }
22875    ///Bit 0.
22876    pub const UNIFORM_TILE_SPACING_FLAG_SET: Self = Self(1u32);
22877    ///Bit 1.
22878    pub const SKIP_MODE_PRESENT_UNSET: Self = Self(2u32);
22879    ///Bit 2.
22880    pub const PRIMARY_REF_FRAME: Self = Self(4u32);
22881    ///Bit 3.
22882    pub const DELTA_Q: Self = Self(8u32);
22883}
22884impl core::ops::BitOr for VideoEncodeAV1StdFlagBitsKHR {
22885    type Output = Self;
22886    #[inline]
22887    fn bitor(self, rhs: Self) -> Self {
22888        Self(self.0 | rhs.0)
22889    }
22890}
22891impl core::ops::BitOrAssign for VideoEncodeAV1StdFlagBitsKHR {
22892    #[inline]
22893    fn bitor_assign(&mut self, rhs: Self) {
22894        self.0 |= rhs.0;
22895    }
22896}
22897impl core::ops::BitAnd for VideoEncodeAV1StdFlagBitsKHR {
22898    type Output = Self;
22899    #[inline]
22900    fn bitand(self, rhs: Self) -> Self {
22901        Self(self.0 & rhs.0)
22902    }
22903}
22904impl core::ops::BitAndAssign for VideoEncodeAV1StdFlagBitsKHR {
22905    #[inline]
22906    fn bitand_assign(&mut self, rhs: Self) {
22907        self.0 &= rhs.0;
22908    }
22909}
22910impl core::ops::BitXor for VideoEncodeAV1StdFlagBitsKHR {
22911    type Output = Self;
22912    #[inline]
22913    fn bitxor(self, rhs: Self) -> Self {
22914        Self(self.0 ^ rhs.0)
22915    }
22916}
22917impl core::ops::BitXorAssign for VideoEncodeAV1StdFlagBitsKHR {
22918    #[inline]
22919    fn bitxor_assign(&mut self, rhs: Self) {
22920        self.0 ^= rhs.0;
22921    }
22922}
22923impl core::ops::Not for VideoEncodeAV1StdFlagBitsKHR {
22924    type Output = Self;
22925    #[inline]
22926    fn not(self) -> Self {
22927        Self(!self.0)
22928    }
22929}
22930impl core::fmt::Debug for VideoEncodeAV1StdFlagBitsKHR {
22931    #[allow(unused_mut, unused_variables)]
22932    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
22933        let mut first = true;
22934        let mut remaining = self.0;
22935        if remaining & Self::UNIFORM_TILE_SPACING_FLAG_SET.0 != 0 {
22936            if !first {
22937                f.write_str(" | ")?;
22938            }
22939            f.write_str("UNIFORM_TILE_SPACING_FLAG_SET")?;
22940            remaining &= !Self::UNIFORM_TILE_SPACING_FLAG_SET.0;
22941            first = false;
22942        }
22943        if remaining & Self::SKIP_MODE_PRESENT_UNSET.0 != 0 {
22944            if !first {
22945                f.write_str(" | ")?;
22946            }
22947            f.write_str("SKIP_MODE_PRESENT_UNSET")?;
22948            remaining &= !Self::SKIP_MODE_PRESENT_UNSET.0;
22949            first = false;
22950        }
22951        if remaining & Self::PRIMARY_REF_FRAME.0 != 0 {
22952            if !first {
22953                f.write_str(" | ")?;
22954            }
22955            f.write_str("PRIMARY_REF_FRAME")?;
22956            remaining &= !Self::PRIMARY_REF_FRAME.0;
22957            first = false;
22958        }
22959        if remaining & Self::DELTA_Q.0 != 0 {
22960            if !first {
22961                f.write_str(" | ")?;
22962            }
22963            f.write_str("DELTA_Q")?;
22964            remaining &= !Self::DELTA_Q.0;
22965            first = false;
22966        }
22967        if remaining != 0u32 {
22968            if !first {
22969                f.write_str(" | ")?;
22970            }
22971            write!(f, "{:#x}", remaining)?;
22972        } else if first {
22973            f.write_str("(empty)")?;
22974        }
22975        Ok(())
22976    }
22977}
22978///[`VkVideoEncodeAV1SuperblockSizeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SuperblockSizeFlagBitsKHR.html)
22979#[repr(transparent)]
22980#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
22981#[doc(alias = "VkVideoEncodeAV1SuperblockSizeFlagBitsKHR")]
22982pub struct VideoEncodeAV1SuperblockSizeFlagBitsKHR(u32);
22983impl VideoEncodeAV1SuperblockSizeFlagBitsKHR {
22984    #[inline]
22985    pub const fn empty() -> Self {
22986        Self(0u32)
22987    }
22988    #[inline]
22989    pub const fn from_raw(value: u32) -> Self {
22990        Self(value)
22991    }
22992    #[inline]
22993    pub const fn as_raw(self) -> u32 {
22994        self.0
22995    }
22996    #[inline]
22997    pub const fn is_empty(self) -> bool {
22998        self.0 == 0u32
22999    }
23000    #[inline]
23001    pub const fn contains(self, other: Self) -> bool {
23002        (self.0 & other.0) == other.0
23003    }
23004    ///Bit 0.
23005    pub const _64: Self = Self(1u32);
23006    ///Bit 1.
23007    pub const _128: Self = Self(2u32);
23008}
23009impl core::ops::BitOr for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23010    type Output = Self;
23011    #[inline]
23012    fn bitor(self, rhs: Self) -> Self {
23013        Self(self.0 | rhs.0)
23014    }
23015}
23016impl core::ops::BitOrAssign for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23017    #[inline]
23018    fn bitor_assign(&mut self, rhs: Self) {
23019        self.0 |= rhs.0;
23020    }
23021}
23022impl core::ops::BitAnd for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23023    type Output = Self;
23024    #[inline]
23025    fn bitand(self, rhs: Self) -> Self {
23026        Self(self.0 & rhs.0)
23027    }
23028}
23029impl core::ops::BitAndAssign for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23030    #[inline]
23031    fn bitand_assign(&mut self, rhs: Self) {
23032        self.0 &= rhs.0;
23033    }
23034}
23035impl core::ops::BitXor for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23036    type Output = Self;
23037    #[inline]
23038    fn bitxor(self, rhs: Self) -> Self {
23039        Self(self.0 ^ rhs.0)
23040    }
23041}
23042impl core::ops::BitXorAssign for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23043    #[inline]
23044    fn bitxor_assign(&mut self, rhs: Self) {
23045        self.0 ^= rhs.0;
23046    }
23047}
23048impl core::ops::Not for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23049    type Output = Self;
23050    #[inline]
23051    fn not(self) -> Self {
23052        Self(!self.0)
23053    }
23054}
23055impl core::fmt::Debug for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
23056    #[allow(unused_mut, unused_variables)]
23057    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23058        let mut first = true;
23059        let mut remaining = self.0;
23060        if remaining & Self::_64.0 != 0 {
23061            if !first {
23062                f.write_str(" | ")?;
23063            }
23064            f.write_str("_64")?;
23065            remaining &= !Self::_64.0;
23066            first = false;
23067        }
23068        if remaining & Self::_128.0 != 0 {
23069            if !first {
23070                f.write_str(" | ")?;
23071            }
23072            f.write_str("_128")?;
23073            remaining &= !Self::_128.0;
23074            first = false;
23075        }
23076        if remaining != 0u32 {
23077            if !first {
23078                f.write_str(" | ")?;
23079            }
23080            write!(f, "{:#x}", remaining)?;
23081        } else if first {
23082            f.write_str("(empty)")?;
23083        }
23084        Ok(())
23085    }
23086}
23087///[`VkVideoEncodeCapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeCapabilityFlagBitsKHR.html)
23088#[repr(transparent)]
23089#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
23090#[doc(alias = "VkVideoEncodeCapabilityFlagBitsKHR")]
23091pub struct VideoEncodeCapabilityFlagBitsKHR(u32);
23092impl VideoEncodeCapabilityFlagBitsKHR {
23093    #[inline]
23094    pub const fn empty() -> Self {
23095        Self(0u32)
23096    }
23097    #[inline]
23098    pub const fn from_raw(value: u32) -> Self {
23099        Self(value)
23100    }
23101    #[inline]
23102    pub const fn as_raw(self) -> u32 {
23103        self.0
23104    }
23105    #[inline]
23106    pub const fn is_empty(self) -> bool {
23107        self.0 == 0u32
23108    }
23109    #[inline]
23110    pub const fn contains(self, other: Self) -> bool {
23111        (self.0 & other.0) == other.0
23112    }
23113    ///Bit 0.
23114    pub const PRECEDING_EXTERNALLY_ENCODED_BYTES: Self = Self(1u32);
23115    ///Bit 1.
23116    pub const INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION: Self = Self(2u32);
23117    ///Bit 2.
23118    pub const QUANTIZATION_DELTA_MAP: Self = Self(4u32);
23119    ///Bit 3.
23120    pub const EMPHASIS_MAP: Self = Self(8u32);
23121}
23122impl core::ops::BitOr for VideoEncodeCapabilityFlagBitsKHR {
23123    type Output = Self;
23124    #[inline]
23125    fn bitor(self, rhs: Self) -> Self {
23126        Self(self.0 | rhs.0)
23127    }
23128}
23129impl core::ops::BitOrAssign for VideoEncodeCapabilityFlagBitsKHR {
23130    #[inline]
23131    fn bitor_assign(&mut self, rhs: Self) {
23132        self.0 |= rhs.0;
23133    }
23134}
23135impl core::ops::BitAnd for VideoEncodeCapabilityFlagBitsKHR {
23136    type Output = Self;
23137    #[inline]
23138    fn bitand(self, rhs: Self) -> Self {
23139        Self(self.0 & rhs.0)
23140    }
23141}
23142impl core::ops::BitAndAssign for VideoEncodeCapabilityFlagBitsKHR {
23143    #[inline]
23144    fn bitand_assign(&mut self, rhs: Self) {
23145        self.0 &= rhs.0;
23146    }
23147}
23148impl core::ops::BitXor for VideoEncodeCapabilityFlagBitsKHR {
23149    type Output = Self;
23150    #[inline]
23151    fn bitxor(self, rhs: Self) -> Self {
23152        Self(self.0 ^ rhs.0)
23153    }
23154}
23155impl core::ops::BitXorAssign for VideoEncodeCapabilityFlagBitsKHR {
23156    #[inline]
23157    fn bitxor_assign(&mut self, rhs: Self) {
23158        self.0 ^= rhs.0;
23159    }
23160}
23161impl core::ops::Not for VideoEncodeCapabilityFlagBitsKHR {
23162    type Output = Self;
23163    #[inline]
23164    fn not(self) -> Self {
23165        Self(!self.0)
23166    }
23167}
23168impl core::fmt::Debug for VideoEncodeCapabilityFlagBitsKHR {
23169    #[allow(unused_mut, unused_variables)]
23170    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23171        let mut first = true;
23172        let mut remaining = self.0;
23173        if remaining & Self::PRECEDING_EXTERNALLY_ENCODED_BYTES.0 != 0 {
23174            if !first {
23175                f.write_str(" | ")?;
23176            }
23177            f.write_str("PRECEDING_EXTERNALLY_ENCODED_BYTES")?;
23178            remaining &= !Self::PRECEDING_EXTERNALLY_ENCODED_BYTES.0;
23179            first = false;
23180        }
23181        if remaining & Self::INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION.0 != 0 {
23182            if !first {
23183                f.write_str(" | ")?;
23184            }
23185            f.write_str("INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION")?;
23186            remaining &= !Self::INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION.0;
23187            first = false;
23188        }
23189        if remaining & Self::QUANTIZATION_DELTA_MAP.0 != 0 {
23190            if !first {
23191                f.write_str(" | ")?;
23192            }
23193            f.write_str("QUANTIZATION_DELTA_MAP")?;
23194            remaining &= !Self::QUANTIZATION_DELTA_MAP.0;
23195            first = false;
23196        }
23197        if remaining & Self::EMPHASIS_MAP.0 != 0 {
23198            if !first {
23199                f.write_str(" | ")?;
23200            }
23201            f.write_str("EMPHASIS_MAP")?;
23202            remaining &= !Self::EMPHASIS_MAP.0;
23203            first = false;
23204        }
23205        if remaining != 0u32 {
23206            if !first {
23207                f.write_str(" | ")?;
23208            }
23209            write!(f, "{:#x}", remaining)?;
23210        } else if first {
23211            f.write_str("(empty)")?;
23212        }
23213        Ok(())
23214    }
23215}
23216///[`VkVideoEncodeContentFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeContentFlagBitsKHR.html)
23217#[repr(transparent)]
23218#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
23219#[doc(alias = "VkVideoEncodeContentFlagBitsKHR")]
23220pub struct VideoEncodeContentFlagBitsKHR(u32);
23221impl VideoEncodeContentFlagBitsKHR {
23222    #[inline]
23223    pub const fn empty() -> Self {
23224        Self(0u32)
23225    }
23226    #[inline]
23227    pub const fn from_raw(value: u32) -> Self {
23228        Self(value)
23229    }
23230    #[inline]
23231    pub const fn as_raw(self) -> u32 {
23232        self.0
23233    }
23234    #[inline]
23235    pub const fn is_empty(self) -> bool {
23236        self.0 == 0u32
23237    }
23238    #[inline]
23239    pub const fn contains(self, other: Self) -> bool {
23240        (self.0 & other.0) == other.0
23241    }
23242    pub const DEFAULT: Self = Self(0u32);
23243    ///Bit 0.
23244    pub const CAMERA: Self = Self(1u32);
23245    ///Bit 1.
23246    pub const DESKTOP: Self = Self(2u32);
23247    ///Bit 2.
23248    pub const RENDERED: Self = Self(4u32);
23249}
23250impl core::ops::BitOr for VideoEncodeContentFlagBitsKHR {
23251    type Output = Self;
23252    #[inline]
23253    fn bitor(self, rhs: Self) -> Self {
23254        Self(self.0 | rhs.0)
23255    }
23256}
23257impl core::ops::BitOrAssign for VideoEncodeContentFlagBitsKHR {
23258    #[inline]
23259    fn bitor_assign(&mut self, rhs: Self) {
23260        self.0 |= rhs.0;
23261    }
23262}
23263impl core::ops::BitAnd for VideoEncodeContentFlagBitsKHR {
23264    type Output = Self;
23265    #[inline]
23266    fn bitand(self, rhs: Self) -> Self {
23267        Self(self.0 & rhs.0)
23268    }
23269}
23270impl core::ops::BitAndAssign for VideoEncodeContentFlagBitsKHR {
23271    #[inline]
23272    fn bitand_assign(&mut self, rhs: Self) {
23273        self.0 &= rhs.0;
23274    }
23275}
23276impl core::ops::BitXor for VideoEncodeContentFlagBitsKHR {
23277    type Output = Self;
23278    #[inline]
23279    fn bitxor(self, rhs: Self) -> Self {
23280        Self(self.0 ^ rhs.0)
23281    }
23282}
23283impl core::ops::BitXorAssign for VideoEncodeContentFlagBitsKHR {
23284    #[inline]
23285    fn bitxor_assign(&mut self, rhs: Self) {
23286        self.0 ^= rhs.0;
23287    }
23288}
23289impl core::ops::Not for VideoEncodeContentFlagBitsKHR {
23290    type Output = Self;
23291    #[inline]
23292    fn not(self) -> Self {
23293        Self(!self.0)
23294    }
23295}
23296impl core::fmt::Debug for VideoEncodeContentFlagBitsKHR {
23297    #[allow(unused_mut, unused_variables)]
23298    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23299        let mut first = true;
23300        let mut remaining = self.0;
23301        if remaining & Self::CAMERA.0 != 0 {
23302            if !first {
23303                f.write_str(" | ")?;
23304            }
23305            f.write_str("CAMERA")?;
23306            remaining &= !Self::CAMERA.0;
23307            first = false;
23308        }
23309        if remaining & Self::DESKTOP.0 != 0 {
23310            if !first {
23311                f.write_str(" | ")?;
23312            }
23313            f.write_str("DESKTOP")?;
23314            remaining &= !Self::DESKTOP.0;
23315            first = false;
23316        }
23317        if remaining & Self::RENDERED.0 != 0 {
23318            if !first {
23319                f.write_str(" | ")?;
23320            }
23321            f.write_str("RENDERED")?;
23322            remaining &= !Self::RENDERED.0;
23323            first = false;
23324        }
23325        if remaining != 0u32 {
23326            if !first {
23327                f.write_str(" | ")?;
23328            }
23329            write!(f, "{:#x}", remaining)?;
23330        } else if first {
23331            f.write_str("(empty)")?;
23332        }
23333        Ok(())
23334    }
23335}
23336///[`VkVideoEncodeFeedbackFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFeedbackFlagBitsKHR.html)
23337#[repr(transparent)]
23338#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
23339#[doc(alias = "VkVideoEncodeFeedbackFlagBitsKHR")]
23340pub struct VideoEncodeFeedbackFlagBitsKHR(u32);
23341impl VideoEncodeFeedbackFlagBitsKHR {
23342    #[inline]
23343    pub const fn empty() -> Self {
23344        Self(0u32)
23345    }
23346    #[inline]
23347    pub const fn from_raw(value: u32) -> Self {
23348        Self(value)
23349    }
23350    #[inline]
23351    pub const fn as_raw(self) -> u32 {
23352        self.0
23353    }
23354    #[inline]
23355    pub const fn is_empty(self) -> bool {
23356        self.0 == 0u32
23357    }
23358    #[inline]
23359    pub const fn contains(self, other: Self) -> bool {
23360        (self.0 & other.0) == other.0
23361    }
23362    ///Bit 0.
23363    pub const BITSTREAM_BUFFER_OFFSET: Self = Self(1u32);
23364    ///Bit 1.
23365    pub const BITSTREAM_BYTES_WRITTEN: Self = Self(2u32);
23366    ///Bit 2.
23367    pub const BITSTREAM_HAS_OVERRIDES: Self = Self(4u32);
23368}
23369impl core::ops::BitOr for VideoEncodeFeedbackFlagBitsKHR {
23370    type Output = Self;
23371    #[inline]
23372    fn bitor(self, rhs: Self) -> Self {
23373        Self(self.0 | rhs.0)
23374    }
23375}
23376impl core::ops::BitOrAssign for VideoEncodeFeedbackFlagBitsKHR {
23377    #[inline]
23378    fn bitor_assign(&mut self, rhs: Self) {
23379        self.0 |= rhs.0;
23380    }
23381}
23382impl core::ops::BitAnd for VideoEncodeFeedbackFlagBitsKHR {
23383    type Output = Self;
23384    #[inline]
23385    fn bitand(self, rhs: Self) -> Self {
23386        Self(self.0 & rhs.0)
23387    }
23388}
23389impl core::ops::BitAndAssign for VideoEncodeFeedbackFlagBitsKHR {
23390    #[inline]
23391    fn bitand_assign(&mut self, rhs: Self) {
23392        self.0 &= rhs.0;
23393    }
23394}
23395impl core::ops::BitXor for VideoEncodeFeedbackFlagBitsKHR {
23396    type Output = Self;
23397    #[inline]
23398    fn bitxor(self, rhs: Self) -> Self {
23399        Self(self.0 ^ rhs.0)
23400    }
23401}
23402impl core::ops::BitXorAssign for VideoEncodeFeedbackFlagBitsKHR {
23403    #[inline]
23404    fn bitxor_assign(&mut self, rhs: Self) {
23405        self.0 ^= rhs.0;
23406    }
23407}
23408impl core::ops::Not for VideoEncodeFeedbackFlagBitsKHR {
23409    type Output = Self;
23410    #[inline]
23411    fn not(self) -> Self {
23412        Self(!self.0)
23413    }
23414}
23415impl core::fmt::Debug for VideoEncodeFeedbackFlagBitsKHR {
23416    #[allow(unused_mut, unused_variables)]
23417    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23418        let mut first = true;
23419        let mut remaining = self.0;
23420        if remaining & Self::BITSTREAM_BUFFER_OFFSET.0 != 0 {
23421            if !first {
23422                f.write_str(" | ")?;
23423            }
23424            f.write_str("BITSTREAM_BUFFER_OFFSET")?;
23425            remaining &= !Self::BITSTREAM_BUFFER_OFFSET.0;
23426            first = false;
23427        }
23428        if remaining & Self::BITSTREAM_BYTES_WRITTEN.0 != 0 {
23429            if !first {
23430                f.write_str(" | ")?;
23431            }
23432            f.write_str("BITSTREAM_BYTES_WRITTEN")?;
23433            remaining &= !Self::BITSTREAM_BYTES_WRITTEN.0;
23434            first = false;
23435        }
23436        if remaining & Self::BITSTREAM_HAS_OVERRIDES.0 != 0 {
23437            if !first {
23438                f.write_str(" | ")?;
23439            }
23440            f.write_str("BITSTREAM_HAS_OVERRIDES")?;
23441            remaining &= !Self::BITSTREAM_HAS_OVERRIDES.0;
23442            first = false;
23443        }
23444        if remaining != 0u32 {
23445            if !first {
23446                f.write_str(" | ")?;
23447            }
23448            write!(f, "{:#x}", remaining)?;
23449        } else if first {
23450            f.write_str("(empty)")?;
23451        }
23452        Ok(())
23453    }
23454}
23455///[`VkVideoEncodeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFlagBitsKHR.html)
23456#[repr(transparent)]
23457#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
23458#[doc(alias = "VkVideoEncodeFlagBitsKHR")]
23459pub struct VideoEncodeFlagBitsKHR(u32);
23460impl VideoEncodeFlagBitsKHR {
23461    #[inline]
23462    pub const fn empty() -> Self {
23463        Self(0u32)
23464    }
23465    #[inline]
23466    pub const fn from_raw(value: u32) -> Self {
23467        Self(value)
23468    }
23469    #[inline]
23470    pub const fn as_raw(self) -> u32 {
23471        self.0
23472    }
23473    #[inline]
23474    pub const fn is_empty(self) -> bool {
23475        self.0 == 0u32
23476    }
23477    #[inline]
23478    pub const fn contains(self, other: Self) -> bool {
23479        (self.0 & other.0) == other.0
23480    }
23481    ///Bit 2.
23482    pub const INTRA_REFRESH: Self = Self(4u32);
23483    ///Bit 0.
23484    pub const WITH_QUANTIZATION_DELTA_MAP: Self = Self(1u32);
23485    ///Bit 1.
23486    pub const WITH_EMPHASIS_MAP: Self = Self(2u32);
23487}
23488impl core::ops::BitOr for VideoEncodeFlagBitsKHR {
23489    type Output = Self;
23490    #[inline]
23491    fn bitor(self, rhs: Self) -> Self {
23492        Self(self.0 | rhs.0)
23493    }
23494}
23495impl core::ops::BitOrAssign for VideoEncodeFlagBitsKHR {
23496    #[inline]
23497    fn bitor_assign(&mut self, rhs: Self) {
23498        self.0 |= rhs.0;
23499    }
23500}
23501impl core::ops::BitAnd for VideoEncodeFlagBitsKHR {
23502    type Output = Self;
23503    #[inline]
23504    fn bitand(self, rhs: Self) -> Self {
23505        Self(self.0 & rhs.0)
23506    }
23507}
23508impl core::ops::BitAndAssign for VideoEncodeFlagBitsKHR {
23509    #[inline]
23510    fn bitand_assign(&mut self, rhs: Self) {
23511        self.0 &= rhs.0;
23512    }
23513}
23514impl core::ops::BitXor for VideoEncodeFlagBitsKHR {
23515    type Output = Self;
23516    #[inline]
23517    fn bitxor(self, rhs: Self) -> Self {
23518        Self(self.0 ^ rhs.0)
23519    }
23520}
23521impl core::ops::BitXorAssign for VideoEncodeFlagBitsKHR {
23522    #[inline]
23523    fn bitxor_assign(&mut self, rhs: Self) {
23524        self.0 ^= rhs.0;
23525    }
23526}
23527impl core::ops::Not for VideoEncodeFlagBitsKHR {
23528    type Output = Self;
23529    #[inline]
23530    fn not(self) -> Self {
23531        Self(!self.0)
23532    }
23533}
23534impl core::fmt::Debug for VideoEncodeFlagBitsKHR {
23535    #[allow(unused_mut, unused_variables)]
23536    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23537        let mut first = true;
23538        let mut remaining = self.0;
23539        if remaining & Self::INTRA_REFRESH.0 != 0 {
23540            if !first {
23541                f.write_str(" | ")?;
23542            }
23543            f.write_str("INTRA_REFRESH")?;
23544            remaining &= !Self::INTRA_REFRESH.0;
23545            first = false;
23546        }
23547        if remaining & Self::WITH_QUANTIZATION_DELTA_MAP.0 != 0 {
23548            if !first {
23549                f.write_str(" | ")?;
23550            }
23551            f.write_str("WITH_QUANTIZATION_DELTA_MAP")?;
23552            remaining &= !Self::WITH_QUANTIZATION_DELTA_MAP.0;
23553            first = false;
23554        }
23555        if remaining & Self::WITH_EMPHASIS_MAP.0 != 0 {
23556            if !first {
23557                f.write_str(" | ")?;
23558            }
23559            f.write_str("WITH_EMPHASIS_MAP")?;
23560            remaining &= !Self::WITH_EMPHASIS_MAP.0;
23561            first = false;
23562        }
23563        if remaining != 0u32 {
23564            if !first {
23565                f.write_str(" | ")?;
23566            }
23567            write!(f, "{:#x}", remaining)?;
23568        } else if first {
23569            f.write_str("(empty)")?;
23570        }
23571        Ok(())
23572    }
23573}
23574///[`VkVideoEncodeH264CapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilityFlagBitsKHR.html)
23575#[repr(transparent)]
23576#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
23577#[doc(alias = "VkVideoEncodeH264CapabilityFlagBitsKHR")]
23578pub struct VideoEncodeH264CapabilityFlagBitsKHR(u32);
23579impl VideoEncodeH264CapabilityFlagBitsKHR {
23580    #[inline]
23581    pub const fn empty() -> Self {
23582        Self(0u32)
23583    }
23584    #[inline]
23585    pub const fn from_raw(value: u32) -> Self {
23586        Self(value)
23587    }
23588    #[inline]
23589    pub const fn as_raw(self) -> u32 {
23590        self.0
23591    }
23592    #[inline]
23593    pub const fn is_empty(self) -> bool {
23594        self.0 == 0u32
23595    }
23596    #[inline]
23597    pub const fn contains(self, other: Self) -> bool {
23598        (self.0 & other.0) == other.0
23599    }
23600    ///Bit 0.
23601    pub const HRD_COMPLIANCE: Self = Self(1u32);
23602    ///Bit 1.
23603    pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(2u32);
23604    ///Bit 2.
23605    pub const ROW_UNALIGNED_SLICE: Self = Self(4u32);
23606    ///Bit 3.
23607    pub const DIFFERENT_SLICE_TYPE: Self = Self(8u32);
23608    ///Bit 4.
23609    pub const B_FRAME_IN_L0_LIST: Self = Self(16u32);
23610    ///Bit 5.
23611    pub const B_FRAME_IN_L1_LIST: Self = Self(32u32);
23612    ///Bit 6.
23613    pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(64u32);
23614    ///Bit 7.
23615    pub const PER_SLICE_CONSTANT_QP: Self = Self(128u32);
23616    ///Bit 8.
23617    pub const GENERATE_PREFIX_NALU: Self = Self(256u32);
23618    ///Bit 10.
23619    pub const B_PICTURE_INTRA_REFRESH: Self = Self(1024u32);
23620    ///Bit 9.
23621    pub const MB_QP_DIFF_WRAPAROUND: Self = Self(512u32);
23622}
23623impl core::ops::BitOr for VideoEncodeH264CapabilityFlagBitsKHR {
23624    type Output = Self;
23625    #[inline]
23626    fn bitor(self, rhs: Self) -> Self {
23627        Self(self.0 | rhs.0)
23628    }
23629}
23630impl core::ops::BitOrAssign for VideoEncodeH264CapabilityFlagBitsKHR {
23631    #[inline]
23632    fn bitor_assign(&mut self, rhs: Self) {
23633        self.0 |= rhs.0;
23634    }
23635}
23636impl core::ops::BitAnd for VideoEncodeH264CapabilityFlagBitsKHR {
23637    type Output = Self;
23638    #[inline]
23639    fn bitand(self, rhs: Self) -> Self {
23640        Self(self.0 & rhs.0)
23641    }
23642}
23643impl core::ops::BitAndAssign for VideoEncodeH264CapabilityFlagBitsKHR {
23644    #[inline]
23645    fn bitand_assign(&mut self, rhs: Self) {
23646        self.0 &= rhs.0;
23647    }
23648}
23649impl core::ops::BitXor for VideoEncodeH264CapabilityFlagBitsKHR {
23650    type Output = Self;
23651    #[inline]
23652    fn bitxor(self, rhs: Self) -> Self {
23653        Self(self.0 ^ rhs.0)
23654    }
23655}
23656impl core::ops::BitXorAssign for VideoEncodeH264CapabilityFlagBitsKHR {
23657    #[inline]
23658    fn bitxor_assign(&mut self, rhs: Self) {
23659        self.0 ^= rhs.0;
23660    }
23661}
23662impl core::ops::Not for VideoEncodeH264CapabilityFlagBitsKHR {
23663    type Output = Self;
23664    #[inline]
23665    fn not(self) -> Self {
23666        Self(!self.0)
23667    }
23668}
23669impl core::fmt::Debug for VideoEncodeH264CapabilityFlagBitsKHR {
23670    #[allow(unused_mut, unused_variables)]
23671    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23672        let mut first = true;
23673        let mut remaining = self.0;
23674        if remaining & Self::HRD_COMPLIANCE.0 != 0 {
23675            if !first {
23676                f.write_str(" | ")?;
23677            }
23678            f.write_str("HRD_COMPLIANCE")?;
23679            remaining &= !Self::HRD_COMPLIANCE.0;
23680            first = false;
23681        }
23682        if remaining & Self::PREDICTION_WEIGHT_TABLE_GENERATED.0 != 0 {
23683            if !first {
23684                f.write_str(" | ")?;
23685            }
23686            f.write_str("PREDICTION_WEIGHT_TABLE_GENERATED")?;
23687            remaining &= !Self::PREDICTION_WEIGHT_TABLE_GENERATED.0;
23688            first = false;
23689        }
23690        if remaining & Self::ROW_UNALIGNED_SLICE.0 != 0 {
23691            if !first {
23692                f.write_str(" | ")?;
23693            }
23694            f.write_str("ROW_UNALIGNED_SLICE")?;
23695            remaining &= !Self::ROW_UNALIGNED_SLICE.0;
23696            first = false;
23697        }
23698        if remaining & Self::DIFFERENT_SLICE_TYPE.0 != 0 {
23699            if !first {
23700                f.write_str(" | ")?;
23701            }
23702            f.write_str("DIFFERENT_SLICE_TYPE")?;
23703            remaining &= !Self::DIFFERENT_SLICE_TYPE.0;
23704            first = false;
23705        }
23706        if remaining & Self::B_FRAME_IN_L0_LIST.0 != 0 {
23707            if !first {
23708                f.write_str(" | ")?;
23709            }
23710            f.write_str("B_FRAME_IN_L0_LIST")?;
23711            remaining &= !Self::B_FRAME_IN_L0_LIST.0;
23712            first = false;
23713        }
23714        if remaining & Self::B_FRAME_IN_L1_LIST.0 != 0 {
23715            if !first {
23716                f.write_str(" | ")?;
23717            }
23718            f.write_str("B_FRAME_IN_L1_LIST")?;
23719            remaining &= !Self::B_FRAME_IN_L1_LIST.0;
23720            first = false;
23721        }
23722        if remaining & Self::PER_PICTURE_TYPE_MIN_MAX_QP.0 != 0 {
23723            if !first {
23724                f.write_str(" | ")?;
23725            }
23726            f.write_str("PER_PICTURE_TYPE_MIN_MAX_QP")?;
23727            remaining &= !Self::PER_PICTURE_TYPE_MIN_MAX_QP.0;
23728            first = false;
23729        }
23730        if remaining & Self::PER_SLICE_CONSTANT_QP.0 != 0 {
23731            if !first {
23732                f.write_str(" | ")?;
23733            }
23734            f.write_str("PER_SLICE_CONSTANT_QP")?;
23735            remaining &= !Self::PER_SLICE_CONSTANT_QP.0;
23736            first = false;
23737        }
23738        if remaining & Self::GENERATE_PREFIX_NALU.0 != 0 {
23739            if !first {
23740                f.write_str(" | ")?;
23741            }
23742            f.write_str("GENERATE_PREFIX_NALU")?;
23743            remaining &= !Self::GENERATE_PREFIX_NALU.0;
23744            first = false;
23745        }
23746        if remaining & Self::B_PICTURE_INTRA_REFRESH.0 != 0 {
23747            if !first {
23748                f.write_str(" | ")?;
23749            }
23750            f.write_str("B_PICTURE_INTRA_REFRESH")?;
23751            remaining &= !Self::B_PICTURE_INTRA_REFRESH.0;
23752            first = false;
23753        }
23754        if remaining & Self::MB_QP_DIFF_WRAPAROUND.0 != 0 {
23755            if !first {
23756                f.write_str(" | ")?;
23757            }
23758            f.write_str("MB_QP_DIFF_WRAPAROUND")?;
23759            remaining &= !Self::MB_QP_DIFF_WRAPAROUND.0;
23760            first = false;
23761        }
23762        if remaining != 0u32 {
23763            if !first {
23764                f.write_str(" | ")?;
23765            }
23766            write!(f, "{:#x}", remaining)?;
23767        } else if first {
23768            f.write_str("(empty)")?;
23769        }
23770        Ok(())
23771    }
23772}
23773///[`VkVideoEncodeH264RateControlFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlFlagBitsKHR.html)
23774#[repr(transparent)]
23775#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
23776#[doc(alias = "VkVideoEncodeH264RateControlFlagBitsKHR")]
23777pub struct VideoEncodeH264RateControlFlagBitsKHR(u32);
23778impl VideoEncodeH264RateControlFlagBitsKHR {
23779    #[inline]
23780    pub const fn empty() -> Self {
23781        Self(0u32)
23782    }
23783    #[inline]
23784    pub const fn from_raw(value: u32) -> Self {
23785        Self(value)
23786    }
23787    #[inline]
23788    pub const fn as_raw(self) -> u32 {
23789        self.0
23790    }
23791    #[inline]
23792    pub const fn is_empty(self) -> bool {
23793        self.0 == 0u32
23794    }
23795    #[inline]
23796    pub const fn contains(self, other: Self) -> bool {
23797        (self.0 & other.0) == other.0
23798    }
23799    ///Bit 0.
23800    pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(1u32);
23801    ///Bit 1.
23802    pub const REGULAR_GOP: Self = Self(2u32);
23803    ///Bit 2.
23804    pub const REFERENCE_PATTERN_FLAT: Self = Self(4u32);
23805    ///Bit 3.
23806    pub const REFERENCE_PATTERN_DYADIC: Self = Self(8u32);
23807    ///Bit 4.
23808    pub const TEMPORAL_LAYER_PATTERN_DYADIC: Self = Self(16u32);
23809}
23810impl core::ops::BitOr for VideoEncodeH264RateControlFlagBitsKHR {
23811    type Output = Self;
23812    #[inline]
23813    fn bitor(self, rhs: Self) -> Self {
23814        Self(self.0 | rhs.0)
23815    }
23816}
23817impl core::ops::BitOrAssign for VideoEncodeH264RateControlFlagBitsKHR {
23818    #[inline]
23819    fn bitor_assign(&mut self, rhs: Self) {
23820        self.0 |= rhs.0;
23821    }
23822}
23823impl core::ops::BitAnd for VideoEncodeH264RateControlFlagBitsKHR {
23824    type Output = Self;
23825    #[inline]
23826    fn bitand(self, rhs: Self) -> Self {
23827        Self(self.0 & rhs.0)
23828    }
23829}
23830impl core::ops::BitAndAssign for VideoEncodeH264RateControlFlagBitsKHR {
23831    #[inline]
23832    fn bitand_assign(&mut self, rhs: Self) {
23833        self.0 &= rhs.0;
23834    }
23835}
23836impl core::ops::BitXor for VideoEncodeH264RateControlFlagBitsKHR {
23837    type Output = Self;
23838    #[inline]
23839    fn bitxor(self, rhs: Self) -> Self {
23840        Self(self.0 ^ rhs.0)
23841    }
23842}
23843impl core::ops::BitXorAssign for VideoEncodeH264RateControlFlagBitsKHR {
23844    #[inline]
23845    fn bitxor_assign(&mut self, rhs: Self) {
23846        self.0 ^= rhs.0;
23847    }
23848}
23849impl core::ops::Not for VideoEncodeH264RateControlFlagBitsKHR {
23850    type Output = Self;
23851    #[inline]
23852    fn not(self) -> Self {
23853        Self(!self.0)
23854    }
23855}
23856impl core::fmt::Debug for VideoEncodeH264RateControlFlagBitsKHR {
23857    #[allow(unused_mut, unused_variables)]
23858    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
23859        let mut first = true;
23860        let mut remaining = self.0;
23861        if remaining & Self::ATTEMPT_HRD_COMPLIANCE.0 != 0 {
23862            if !first {
23863                f.write_str(" | ")?;
23864            }
23865            f.write_str("ATTEMPT_HRD_COMPLIANCE")?;
23866            remaining &= !Self::ATTEMPT_HRD_COMPLIANCE.0;
23867            first = false;
23868        }
23869        if remaining & Self::REGULAR_GOP.0 != 0 {
23870            if !first {
23871                f.write_str(" | ")?;
23872            }
23873            f.write_str("REGULAR_GOP")?;
23874            remaining &= !Self::REGULAR_GOP.0;
23875            first = false;
23876        }
23877        if remaining & Self::REFERENCE_PATTERN_FLAT.0 != 0 {
23878            if !first {
23879                f.write_str(" | ")?;
23880            }
23881            f.write_str("REFERENCE_PATTERN_FLAT")?;
23882            remaining &= !Self::REFERENCE_PATTERN_FLAT.0;
23883            first = false;
23884        }
23885        if remaining & Self::REFERENCE_PATTERN_DYADIC.0 != 0 {
23886            if !first {
23887                f.write_str(" | ")?;
23888            }
23889            f.write_str("REFERENCE_PATTERN_DYADIC")?;
23890            remaining &= !Self::REFERENCE_PATTERN_DYADIC.0;
23891            first = false;
23892        }
23893        if remaining & Self::TEMPORAL_LAYER_PATTERN_DYADIC.0 != 0 {
23894            if !first {
23895                f.write_str(" | ")?;
23896            }
23897            f.write_str("TEMPORAL_LAYER_PATTERN_DYADIC")?;
23898            remaining &= !Self::TEMPORAL_LAYER_PATTERN_DYADIC.0;
23899            first = false;
23900        }
23901        if remaining != 0u32 {
23902            if !first {
23903                f.write_str(" | ")?;
23904            }
23905            write!(f, "{:#x}", remaining)?;
23906        } else if first {
23907            f.write_str("(empty)")?;
23908        }
23909        Ok(())
23910    }
23911}
23912///[`VkVideoEncodeH264StdFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264StdFlagBitsKHR.html)
23913#[repr(transparent)]
23914#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
23915#[doc(alias = "VkVideoEncodeH264StdFlagBitsKHR")]
23916pub struct VideoEncodeH264StdFlagBitsKHR(u32);
23917impl VideoEncodeH264StdFlagBitsKHR {
23918    #[inline]
23919    pub const fn empty() -> Self {
23920        Self(0u32)
23921    }
23922    #[inline]
23923    pub const fn from_raw(value: u32) -> Self {
23924        Self(value)
23925    }
23926    #[inline]
23927    pub const fn as_raw(self) -> u32 {
23928        self.0
23929    }
23930    #[inline]
23931    pub const fn is_empty(self) -> bool {
23932        self.0 == 0u32
23933    }
23934    #[inline]
23935    pub const fn contains(self, other: Self) -> bool {
23936        (self.0 & other.0) == other.0
23937    }
23938    ///Bit 0.
23939    pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(1u32);
23940    ///Bit 1.
23941    pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET: Self = Self(2u32);
23942    ///Bit 2.
23943    pub const SCALING_MATRIX_PRESENT_FLAG_SET: Self = Self(4u32);
23944    ///Bit 3.
23945    pub const CHROMA_QP_INDEX_OFFSET: Self = Self(8u32);
23946    ///Bit 4.
23947    pub const SECOND_CHROMA_QP_INDEX_OFFSET: Self = Self(16u32);
23948    ///Bit 5.
23949    pub const PIC_INIT_QP_MINUS26: Self = Self(32u32);
23950    ///Bit 6.
23951    pub const WEIGHTED_PRED_FLAG_SET: Self = Self(64u32);
23952    ///Bit 7.
23953    pub const WEIGHTED_BIPRED_IDC_EXPLICIT: Self = Self(128u32);
23954    ///Bit 8.
23955    pub const WEIGHTED_BIPRED_IDC_IMPLICIT: Self = Self(256u32);
23956    ///Bit 9.
23957    pub const TRANSFORM_8X8_MODE_FLAG_SET: Self = Self(512u32);
23958    ///Bit 10.
23959    pub const DIRECT_SPATIAL_MV_PRED_FLAG_UNSET: Self = Self(1024u32);
23960    ///Bit 11.
23961    pub const ENTROPY_CODING_MODE_FLAG_UNSET: Self = Self(2048u32);
23962    ///Bit 12.
23963    pub const ENTROPY_CODING_MODE_FLAG_SET: Self = Self(4096u32);
23964    ///Bit 13.
23965    pub const DIRECT_8X8_INFERENCE_FLAG_UNSET: Self = Self(8192u32);
23966    ///Bit 14.
23967    pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(16384u32);
23968    ///Bit 15.
23969    pub const DEBLOCKING_FILTER_DISABLED: Self = Self(32768u32);
23970    ///Bit 16.
23971    pub const DEBLOCKING_FILTER_ENABLED: Self = Self(65536u32);
23972    ///Bit 17.
23973    pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(131072u32);
23974    ///Bit 19.
23975    pub const SLICE_QP_DELTA: Self = Self(524288u32);
23976    ///Bit 20.
23977    pub const DIFFERENT_SLICE_QP_DELTA: Self = Self(1048576u32);
23978}
23979impl core::ops::BitOr for VideoEncodeH264StdFlagBitsKHR {
23980    type Output = Self;
23981    #[inline]
23982    fn bitor(self, rhs: Self) -> Self {
23983        Self(self.0 | rhs.0)
23984    }
23985}
23986impl core::ops::BitOrAssign for VideoEncodeH264StdFlagBitsKHR {
23987    #[inline]
23988    fn bitor_assign(&mut self, rhs: Self) {
23989        self.0 |= rhs.0;
23990    }
23991}
23992impl core::ops::BitAnd for VideoEncodeH264StdFlagBitsKHR {
23993    type Output = Self;
23994    #[inline]
23995    fn bitand(self, rhs: Self) -> Self {
23996        Self(self.0 & rhs.0)
23997    }
23998}
23999impl core::ops::BitAndAssign for VideoEncodeH264StdFlagBitsKHR {
24000    #[inline]
24001    fn bitand_assign(&mut self, rhs: Self) {
24002        self.0 &= rhs.0;
24003    }
24004}
24005impl core::ops::BitXor for VideoEncodeH264StdFlagBitsKHR {
24006    type Output = Self;
24007    #[inline]
24008    fn bitxor(self, rhs: Self) -> Self {
24009        Self(self.0 ^ rhs.0)
24010    }
24011}
24012impl core::ops::BitXorAssign for VideoEncodeH264StdFlagBitsKHR {
24013    #[inline]
24014    fn bitxor_assign(&mut self, rhs: Self) {
24015        self.0 ^= rhs.0;
24016    }
24017}
24018impl core::ops::Not for VideoEncodeH264StdFlagBitsKHR {
24019    type Output = Self;
24020    #[inline]
24021    fn not(self) -> Self {
24022        Self(!self.0)
24023    }
24024}
24025impl core::fmt::Debug for VideoEncodeH264StdFlagBitsKHR {
24026    #[allow(unused_mut, unused_variables)]
24027    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24028        let mut first = true;
24029        let mut remaining = self.0;
24030        if remaining & Self::SEPARATE_COLOR_PLANE_FLAG_SET.0 != 0 {
24031            if !first {
24032                f.write_str(" | ")?;
24033            }
24034            f.write_str("SEPARATE_COLOR_PLANE_FLAG_SET")?;
24035            remaining &= !Self::SEPARATE_COLOR_PLANE_FLAG_SET.0;
24036            first = false;
24037        }
24038        if remaining & Self::QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET.0 != 0 {
24039            if !first {
24040                f.write_str(" | ")?;
24041            }
24042            f.write_str("QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET")?;
24043            remaining &= !Self::QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET.0;
24044            first = false;
24045        }
24046        if remaining & Self::SCALING_MATRIX_PRESENT_FLAG_SET.0 != 0 {
24047            if !first {
24048                f.write_str(" | ")?;
24049            }
24050            f.write_str("SCALING_MATRIX_PRESENT_FLAG_SET")?;
24051            remaining &= !Self::SCALING_MATRIX_PRESENT_FLAG_SET.0;
24052            first = false;
24053        }
24054        if remaining & Self::CHROMA_QP_INDEX_OFFSET.0 != 0 {
24055            if !first {
24056                f.write_str(" | ")?;
24057            }
24058            f.write_str("CHROMA_QP_INDEX_OFFSET")?;
24059            remaining &= !Self::CHROMA_QP_INDEX_OFFSET.0;
24060            first = false;
24061        }
24062        if remaining & Self::SECOND_CHROMA_QP_INDEX_OFFSET.0 != 0 {
24063            if !first {
24064                f.write_str(" | ")?;
24065            }
24066            f.write_str("SECOND_CHROMA_QP_INDEX_OFFSET")?;
24067            remaining &= !Self::SECOND_CHROMA_QP_INDEX_OFFSET.0;
24068            first = false;
24069        }
24070        if remaining & Self::PIC_INIT_QP_MINUS26.0 != 0 {
24071            if !first {
24072                f.write_str(" | ")?;
24073            }
24074            f.write_str("PIC_INIT_QP_MINUS26")?;
24075            remaining &= !Self::PIC_INIT_QP_MINUS26.0;
24076            first = false;
24077        }
24078        if remaining & Self::WEIGHTED_PRED_FLAG_SET.0 != 0 {
24079            if !first {
24080                f.write_str(" | ")?;
24081            }
24082            f.write_str("WEIGHTED_PRED_FLAG_SET")?;
24083            remaining &= !Self::WEIGHTED_PRED_FLAG_SET.0;
24084            first = false;
24085        }
24086        if remaining & Self::WEIGHTED_BIPRED_IDC_EXPLICIT.0 != 0 {
24087            if !first {
24088                f.write_str(" | ")?;
24089            }
24090            f.write_str("WEIGHTED_BIPRED_IDC_EXPLICIT")?;
24091            remaining &= !Self::WEIGHTED_BIPRED_IDC_EXPLICIT.0;
24092            first = false;
24093        }
24094        if remaining & Self::WEIGHTED_BIPRED_IDC_IMPLICIT.0 != 0 {
24095            if !first {
24096                f.write_str(" | ")?;
24097            }
24098            f.write_str("WEIGHTED_BIPRED_IDC_IMPLICIT")?;
24099            remaining &= !Self::WEIGHTED_BIPRED_IDC_IMPLICIT.0;
24100            first = false;
24101        }
24102        if remaining & Self::TRANSFORM_8X8_MODE_FLAG_SET.0 != 0 {
24103            if !first {
24104                f.write_str(" | ")?;
24105            }
24106            f.write_str("TRANSFORM_8X8_MODE_FLAG_SET")?;
24107            remaining &= !Self::TRANSFORM_8X8_MODE_FLAG_SET.0;
24108            first = false;
24109        }
24110        if remaining & Self::DIRECT_SPATIAL_MV_PRED_FLAG_UNSET.0 != 0 {
24111            if !first {
24112                f.write_str(" | ")?;
24113            }
24114            f.write_str("DIRECT_SPATIAL_MV_PRED_FLAG_UNSET")?;
24115            remaining &= !Self::DIRECT_SPATIAL_MV_PRED_FLAG_UNSET.0;
24116            first = false;
24117        }
24118        if remaining & Self::ENTROPY_CODING_MODE_FLAG_UNSET.0 != 0 {
24119            if !first {
24120                f.write_str(" | ")?;
24121            }
24122            f.write_str("ENTROPY_CODING_MODE_FLAG_UNSET")?;
24123            remaining &= !Self::ENTROPY_CODING_MODE_FLAG_UNSET.0;
24124            first = false;
24125        }
24126        if remaining & Self::ENTROPY_CODING_MODE_FLAG_SET.0 != 0 {
24127            if !first {
24128                f.write_str(" | ")?;
24129            }
24130            f.write_str("ENTROPY_CODING_MODE_FLAG_SET")?;
24131            remaining &= !Self::ENTROPY_CODING_MODE_FLAG_SET.0;
24132            first = false;
24133        }
24134        if remaining & Self::DIRECT_8X8_INFERENCE_FLAG_UNSET.0 != 0 {
24135            if !first {
24136                f.write_str(" | ")?;
24137            }
24138            f.write_str("DIRECT_8X8_INFERENCE_FLAG_UNSET")?;
24139            remaining &= !Self::DIRECT_8X8_INFERENCE_FLAG_UNSET.0;
24140            first = false;
24141        }
24142        if remaining & Self::CONSTRAINED_INTRA_PRED_FLAG_SET.0 != 0 {
24143            if !first {
24144                f.write_str(" | ")?;
24145            }
24146            f.write_str("CONSTRAINED_INTRA_PRED_FLAG_SET")?;
24147            remaining &= !Self::CONSTRAINED_INTRA_PRED_FLAG_SET.0;
24148            first = false;
24149        }
24150        if remaining & Self::DEBLOCKING_FILTER_DISABLED.0 != 0 {
24151            if !first {
24152                f.write_str(" | ")?;
24153            }
24154            f.write_str("DEBLOCKING_FILTER_DISABLED")?;
24155            remaining &= !Self::DEBLOCKING_FILTER_DISABLED.0;
24156            first = false;
24157        }
24158        if remaining & Self::DEBLOCKING_FILTER_ENABLED.0 != 0 {
24159            if !first {
24160                f.write_str(" | ")?;
24161            }
24162            f.write_str("DEBLOCKING_FILTER_ENABLED")?;
24163            remaining &= !Self::DEBLOCKING_FILTER_ENABLED.0;
24164            first = false;
24165        }
24166        if remaining & Self::DEBLOCKING_FILTER_PARTIAL.0 != 0 {
24167            if !first {
24168                f.write_str(" | ")?;
24169            }
24170            f.write_str("DEBLOCKING_FILTER_PARTIAL")?;
24171            remaining &= !Self::DEBLOCKING_FILTER_PARTIAL.0;
24172            first = false;
24173        }
24174        if remaining & Self::SLICE_QP_DELTA.0 != 0 {
24175            if !first {
24176                f.write_str(" | ")?;
24177            }
24178            f.write_str("SLICE_QP_DELTA")?;
24179            remaining &= !Self::SLICE_QP_DELTA.0;
24180            first = false;
24181        }
24182        if remaining & Self::DIFFERENT_SLICE_QP_DELTA.0 != 0 {
24183            if !first {
24184                f.write_str(" | ")?;
24185            }
24186            f.write_str("DIFFERENT_SLICE_QP_DELTA")?;
24187            remaining &= !Self::DIFFERENT_SLICE_QP_DELTA.0;
24188            first = false;
24189        }
24190        if remaining != 0u32 {
24191            if !first {
24192                f.write_str(" | ")?;
24193            }
24194            write!(f, "{:#x}", remaining)?;
24195        } else if first {
24196            f.write_str("(empty)")?;
24197        }
24198        Ok(())
24199    }
24200}
24201///[`VkVideoEncodeH265CapabilityFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilityFlagBitsKHR.html)
24202#[repr(transparent)]
24203#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
24204#[doc(alias = "VkVideoEncodeH265CapabilityFlagBitsKHR")]
24205pub struct VideoEncodeH265CapabilityFlagBitsKHR(u32);
24206impl VideoEncodeH265CapabilityFlagBitsKHR {
24207    #[inline]
24208    pub const fn empty() -> Self {
24209        Self(0u32)
24210    }
24211    #[inline]
24212    pub const fn from_raw(value: u32) -> Self {
24213        Self(value)
24214    }
24215    #[inline]
24216    pub const fn as_raw(self) -> u32 {
24217        self.0
24218    }
24219    #[inline]
24220    pub const fn is_empty(self) -> bool {
24221        self.0 == 0u32
24222    }
24223    #[inline]
24224    pub const fn contains(self, other: Self) -> bool {
24225        (self.0 & other.0) == other.0
24226    }
24227    ///Bit 0.
24228    pub const HRD_COMPLIANCE: Self = Self(1u32);
24229    ///Bit 1.
24230    pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(2u32);
24231    ///Bit 2.
24232    pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(4u32);
24233    ///Bit 3.
24234    pub const DIFFERENT_SLICE_SEGMENT_TYPE: Self = Self(8u32);
24235    ///Bit 4.
24236    pub const B_FRAME_IN_L0_LIST: Self = Self(16u32);
24237    ///Bit 5.
24238    pub const B_FRAME_IN_L1_LIST: Self = Self(32u32);
24239    ///Bit 6.
24240    pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(64u32);
24241    ///Bit 7.
24242    pub const PER_SLICE_SEGMENT_CONSTANT_QP: Self = Self(128u32);
24243    ///Bit 8.
24244    pub const MULTIPLE_TILES_PER_SLICE_SEGMENT: Self = Self(256u32);
24245    ///Bit 9.
24246    pub const MULTIPLE_SLICE_SEGMENTS_PER_TILE: Self = Self(512u32);
24247    ///Bit 11.
24248    pub const B_PICTURE_INTRA_REFRESH: Self = Self(2048u32);
24249    ///Bit 10.
24250    pub const CU_QP_DIFF_WRAPAROUND: Self = Self(1024u32);
24251}
24252impl core::ops::BitOr for VideoEncodeH265CapabilityFlagBitsKHR {
24253    type Output = Self;
24254    #[inline]
24255    fn bitor(self, rhs: Self) -> Self {
24256        Self(self.0 | rhs.0)
24257    }
24258}
24259impl core::ops::BitOrAssign for VideoEncodeH265CapabilityFlagBitsKHR {
24260    #[inline]
24261    fn bitor_assign(&mut self, rhs: Self) {
24262        self.0 |= rhs.0;
24263    }
24264}
24265impl core::ops::BitAnd for VideoEncodeH265CapabilityFlagBitsKHR {
24266    type Output = Self;
24267    #[inline]
24268    fn bitand(self, rhs: Self) -> Self {
24269        Self(self.0 & rhs.0)
24270    }
24271}
24272impl core::ops::BitAndAssign for VideoEncodeH265CapabilityFlagBitsKHR {
24273    #[inline]
24274    fn bitand_assign(&mut self, rhs: Self) {
24275        self.0 &= rhs.0;
24276    }
24277}
24278impl core::ops::BitXor for VideoEncodeH265CapabilityFlagBitsKHR {
24279    type Output = Self;
24280    #[inline]
24281    fn bitxor(self, rhs: Self) -> Self {
24282        Self(self.0 ^ rhs.0)
24283    }
24284}
24285impl core::ops::BitXorAssign for VideoEncodeH265CapabilityFlagBitsKHR {
24286    #[inline]
24287    fn bitxor_assign(&mut self, rhs: Self) {
24288        self.0 ^= rhs.0;
24289    }
24290}
24291impl core::ops::Not for VideoEncodeH265CapabilityFlagBitsKHR {
24292    type Output = Self;
24293    #[inline]
24294    fn not(self) -> Self {
24295        Self(!self.0)
24296    }
24297}
24298impl core::fmt::Debug for VideoEncodeH265CapabilityFlagBitsKHR {
24299    #[allow(unused_mut, unused_variables)]
24300    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24301        let mut first = true;
24302        let mut remaining = self.0;
24303        if remaining & Self::HRD_COMPLIANCE.0 != 0 {
24304            if !first {
24305                f.write_str(" | ")?;
24306            }
24307            f.write_str("HRD_COMPLIANCE")?;
24308            remaining &= !Self::HRD_COMPLIANCE.0;
24309            first = false;
24310        }
24311        if remaining & Self::PREDICTION_WEIGHT_TABLE_GENERATED.0 != 0 {
24312            if !first {
24313                f.write_str(" | ")?;
24314            }
24315            f.write_str("PREDICTION_WEIGHT_TABLE_GENERATED")?;
24316            remaining &= !Self::PREDICTION_WEIGHT_TABLE_GENERATED.0;
24317            first = false;
24318        }
24319        if remaining & Self::ROW_UNALIGNED_SLICE_SEGMENT.0 != 0 {
24320            if !first {
24321                f.write_str(" | ")?;
24322            }
24323            f.write_str("ROW_UNALIGNED_SLICE_SEGMENT")?;
24324            remaining &= !Self::ROW_UNALIGNED_SLICE_SEGMENT.0;
24325            first = false;
24326        }
24327        if remaining & Self::DIFFERENT_SLICE_SEGMENT_TYPE.0 != 0 {
24328            if !first {
24329                f.write_str(" | ")?;
24330            }
24331            f.write_str("DIFFERENT_SLICE_SEGMENT_TYPE")?;
24332            remaining &= !Self::DIFFERENT_SLICE_SEGMENT_TYPE.0;
24333            first = false;
24334        }
24335        if remaining & Self::B_FRAME_IN_L0_LIST.0 != 0 {
24336            if !first {
24337                f.write_str(" | ")?;
24338            }
24339            f.write_str("B_FRAME_IN_L0_LIST")?;
24340            remaining &= !Self::B_FRAME_IN_L0_LIST.0;
24341            first = false;
24342        }
24343        if remaining & Self::B_FRAME_IN_L1_LIST.0 != 0 {
24344            if !first {
24345                f.write_str(" | ")?;
24346            }
24347            f.write_str("B_FRAME_IN_L1_LIST")?;
24348            remaining &= !Self::B_FRAME_IN_L1_LIST.0;
24349            first = false;
24350        }
24351        if remaining & Self::PER_PICTURE_TYPE_MIN_MAX_QP.0 != 0 {
24352            if !first {
24353                f.write_str(" | ")?;
24354            }
24355            f.write_str("PER_PICTURE_TYPE_MIN_MAX_QP")?;
24356            remaining &= !Self::PER_PICTURE_TYPE_MIN_MAX_QP.0;
24357            first = false;
24358        }
24359        if remaining & Self::PER_SLICE_SEGMENT_CONSTANT_QP.0 != 0 {
24360            if !first {
24361                f.write_str(" | ")?;
24362            }
24363            f.write_str("PER_SLICE_SEGMENT_CONSTANT_QP")?;
24364            remaining &= !Self::PER_SLICE_SEGMENT_CONSTANT_QP.0;
24365            first = false;
24366        }
24367        if remaining & Self::MULTIPLE_TILES_PER_SLICE_SEGMENT.0 != 0 {
24368            if !first {
24369                f.write_str(" | ")?;
24370            }
24371            f.write_str("MULTIPLE_TILES_PER_SLICE_SEGMENT")?;
24372            remaining &= !Self::MULTIPLE_TILES_PER_SLICE_SEGMENT.0;
24373            first = false;
24374        }
24375        if remaining & Self::MULTIPLE_SLICE_SEGMENTS_PER_TILE.0 != 0 {
24376            if !first {
24377                f.write_str(" | ")?;
24378            }
24379            f.write_str("MULTIPLE_SLICE_SEGMENTS_PER_TILE")?;
24380            remaining &= !Self::MULTIPLE_SLICE_SEGMENTS_PER_TILE.0;
24381            first = false;
24382        }
24383        if remaining & Self::B_PICTURE_INTRA_REFRESH.0 != 0 {
24384            if !first {
24385                f.write_str(" | ")?;
24386            }
24387            f.write_str("B_PICTURE_INTRA_REFRESH")?;
24388            remaining &= !Self::B_PICTURE_INTRA_REFRESH.0;
24389            first = false;
24390        }
24391        if remaining & Self::CU_QP_DIFF_WRAPAROUND.0 != 0 {
24392            if !first {
24393                f.write_str(" | ")?;
24394            }
24395            f.write_str("CU_QP_DIFF_WRAPAROUND")?;
24396            remaining &= !Self::CU_QP_DIFF_WRAPAROUND.0;
24397            first = false;
24398        }
24399        if remaining != 0u32 {
24400            if !first {
24401                f.write_str(" | ")?;
24402            }
24403            write!(f, "{:#x}", remaining)?;
24404        } else if first {
24405            f.write_str("(empty)")?;
24406        }
24407        Ok(())
24408    }
24409}
24410///[`VkVideoEncodeH265CtbSizeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CtbSizeFlagBitsKHR.html)
24411#[repr(transparent)]
24412#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
24413#[doc(alias = "VkVideoEncodeH265CtbSizeFlagBitsKHR")]
24414pub struct VideoEncodeH265CtbSizeFlagBitsKHR(u32);
24415impl VideoEncodeH265CtbSizeFlagBitsKHR {
24416    #[inline]
24417    pub const fn empty() -> Self {
24418        Self(0u32)
24419    }
24420    #[inline]
24421    pub const fn from_raw(value: u32) -> Self {
24422        Self(value)
24423    }
24424    #[inline]
24425    pub const fn as_raw(self) -> u32 {
24426        self.0
24427    }
24428    #[inline]
24429    pub const fn is_empty(self) -> bool {
24430        self.0 == 0u32
24431    }
24432    #[inline]
24433    pub const fn contains(self, other: Self) -> bool {
24434        (self.0 & other.0) == other.0
24435    }
24436    ///Bit 0.
24437    pub const _16: Self = Self(1u32);
24438    ///Bit 1.
24439    pub const _32: Self = Self(2u32);
24440    ///Bit 2.
24441    pub const _64: Self = Self(4u32);
24442}
24443impl core::ops::BitOr for VideoEncodeH265CtbSizeFlagBitsKHR {
24444    type Output = Self;
24445    #[inline]
24446    fn bitor(self, rhs: Self) -> Self {
24447        Self(self.0 | rhs.0)
24448    }
24449}
24450impl core::ops::BitOrAssign for VideoEncodeH265CtbSizeFlagBitsKHR {
24451    #[inline]
24452    fn bitor_assign(&mut self, rhs: Self) {
24453        self.0 |= rhs.0;
24454    }
24455}
24456impl core::ops::BitAnd for VideoEncodeH265CtbSizeFlagBitsKHR {
24457    type Output = Self;
24458    #[inline]
24459    fn bitand(self, rhs: Self) -> Self {
24460        Self(self.0 & rhs.0)
24461    }
24462}
24463impl core::ops::BitAndAssign for VideoEncodeH265CtbSizeFlagBitsKHR {
24464    #[inline]
24465    fn bitand_assign(&mut self, rhs: Self) {
24466        self.0 &= rhs.0;
24467    }
24468}
24469impl core::ops::BitXor for VideoEncodeH265CtbSizeFlagBitsKHR {
24470    type Output = Self;
24471    #[inline]
24472    fn bitxor(self, rhs: Self) -> Self {
24473        Self(self.0 ^ rhs.0)
24474    }
24475}
24476impl core::ops::BitXorAssign for VideoEncodeH265CtbSizeFlagBitsKHR {
24477    #[inline]
24478    fn bitxor_assign(&mut self, rhs: Self) {
24479        self.0 ^= rhs.0;
24480    }
24481}
24482impl core::ops::Not for VideoEncodeH265CtbSizeFlagBitsKHR {
24483    type Output = Self;
24484    #[inline]
24485    fn not(self) -> Self {
24486        Self(!self.0)
24487    }
24488}
24489impl core::fmt::Debug for VideoEncodeH265CtbSizeFlagBitsKHR {
24490    #[allow(unused_mut, unused_variables)]
24491    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24492        let mut first = true;
24493        let mut remaining = self.0;
24494        if remaining & Self::_16.0 != 0 {
24495            if !first {
24496                f.write_str(" | ")?;
24497            }
24498            f.write_str("_16")?;
24499            remaining &= !Self::_16.0;
24500            first = false;
24501        }
24502        if remaining & Self::_32.0 != 0 {
24503            if !first {
24504                f.write_str(" | ")?;
24505            }
24506            f.write_str("_32")?;
24507            remaining &= !Self::_32.0;
24508            first = false;
24509        }
24510        if remaining & Self::_64.0 != 0 {
24511            if !first {
24512                f.write_str(" | ")?;
24513            }
24514            f.write_str("_64")?;
24515            remaining &= !Self::_64.0;
24516            first = false;
24517        }
24518        if remaining != 0u32 {
24519            if !first {
24520                f.write_str(" | ")?;
24521            }
24522            write!(f, "{:#x}", remaining)?;
24523        } else if first {
24524            f.write_str("(empty)")?;
24525        }
24526        Ok(())
24527    }
24528}
24529///[`VkVideoEncodeH265RateControlFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlFlagBitsKHR.html)
24530#[repr(transparent)]
24531#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
24532#[doc(alias = "VkVideoEncodeH265RateControlFlagBitsKHR")]
24533pub struct VideoEncodeH265RateControlFlagBitsKHR(u32);
24534impl VideoEncodeH265RateControlFlagBitsKHR {
24535    #[inline]
24536    pub const fn empty() -> Self {
24537        Self(0u32)
24538    }
24539    #[inline]
24540    pub const fn from_raw(value: u32) -> Self {
24541        Self(value)
24542    }
24543    #[inline]
24544    pub const fn as_raw(self) -> u32 {
24545        self.0
24546    }
24547    #[inline]
24548    pub const fn is_empty(self) -> bool {
24549        self.0 == 0u32
24550    }
24551    #[inline]
24552    pub const fn contains(self, other: Self) -> bool {
24553        (self.0 & other.0) == other.0
24554    }
24555    ///Bit 0.
24556    pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(1u32);
24557    ///Bit 1.
24558    pub const REGULAR_GOP: Self = Self(2u32);
24559    ///Bit 2.
24560    pub const REFERENCE_PATTERN_FLAT: Self = Self(4u32);
24561    ///Bit 3.
24562    pub const REFERENCE_PATTERN_DYADIC: Self = Self(8u32);
24563    ///Bit 4.
24564    pub const TEMPORAL_SUB_LAYER_PATTERN_DYADIC: Self = Self(16u32);
24565}
24566impl core::ops::BitOr for VideoEncodeH265RateControlFlagBitsKHR {
24567    type Output = Self;
24568    #[inline]
24569    fn bitor(self, rhs: Self) -> Self {
24570        Self(self.0 | rhs.0)
24571    }
24572}
24573impl core::ops::BitOrAssign for VideoEncodeH265RateControlFlagBitsKHR {
24574    #[inline]
24575    fn bitor_assign(&mut self, rhs: Self) {
24576        self.0 |= rhs.0;
24577    }
24578}
24579impl core::ops::BitAnd for VideoEncodeH265RateControlFlagBitsKHR {
24580    type Output = Self;
24581    #[inline]
24582    fn bitand(self, rhs: Self) -> Self {
24583        Self(self.0 & rhs.0)
24584    }
24585}
24586impl core::ops::BitAndAssign for VideoEncodeH265RateControlFlagBitsKHR {
24587    #[inline]
24588    fn bitand_assign(&mut self, rhs: Self) {
24589        self.0 &= rhs.0;
24590    }
24591}
24592impl core::ops::BitXor for VideoEncodeH265RateControlFlagBitsKHR {
24593    type Output = Self;
24594    #[inline]
24595    fn bitxor(self, rhs: Self) -> Self {
24596        Self(self.0 ^ rhs.0)
24597    }
24598}
24599impl core::ops::BitXorAssign for VideoEncodeH265RateControlFlagBitsKHR {
24600    #[inline]
24601    fn bitxor_assign(&mut self, rhs: Self) {
24602        self.0 ^= rhs.0;
24603    }
24604}
24605impl core::ops::Not for VideoEncodeH265RateControlFlagBitsKHR {
24606    type Output = Self;
24607    #[inline]
24608    fn not(self) -> Self {
24609        Self(!self.0)
24610    }
24611}
24612impl core::fmt::Debug for VideoEncodeH265RateControlFlagBitsKHR {
24613    #[allow(unused_mut, unused_variables)]
24614    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24615        let mut first = true;
24616        let mut remaining = self.0;
24617        if remaining & Self::ATTEMPT_HRD_COMPLIANCE.0 != 0 {
24618            if !first {
24619                f.write_str(" | ")?;
24620            }
24621            f.write_str("ATTEMPT_HRD_COMPLIANCE")?;
24622            remaining &= !Self::ATTEMPT_HRD_COMPLIANCE.0;
24623            first = false;
24624        }
24625        if remaining & Self::REGULAR_GOP.0 != 0 {
24626            if !first {
24627                f.write_str(" | ")?;
24628            }
24629            f.write_str("REGULAR_GOP")?;
24630            remaining &= !Self::REGULAR_GOP.0;
24631            first = false;
24632        }
24633        if remaining & Self::REFERENCE_PATTERN_FLAT.0 != 0 {
24634            if !first {
24635                f.write_str(" | ")?;
24636            }
24637            f.write_str("REFERENCE_PATTERN_FLAT")?;
24638            remaining &= !Self::REFERENCE_PATTERN_FLAT.0;
24639            first = false;
24640        }
24641        if remaining & Self::REFERENCE_PATTERN_DYADIC.0 != 0 {
24642            if !first {
24643                f.write_str(" | ")?;
24644            }
24645            f.write_str("REFERENCE_PATTERN_DYADIC")?;
24646            remaining &= !Self::REFERENCE_PATTERN_DYADIC.0;
24647            first = false;
24648        }
24649        if remaining & Self::TEMPORAL_SUB_LAYER_PATTERN_DYADIC.0 != 0 {
24650            if !first {
24651                f.write_str(" | ")?;
24652            }
24653            f.write_str("TEMPORAL_SUB_LAYER_PATTERN_DYADIC")?;
24654            remaining &= !Self::TEMPORAL_SUB_LAYER_PATTERN_DYADIC.0;
24655            first = false;
24656        }
24657        if remaining != 0u32 {
24658            if !first {
24659                f.write_str(" | ")?;
24660            }
24661            write!(f, "{:#x}", remaining)?;
24662        } else if first {
24663            f.write_str("(empty)")?;
24664        }
24665        Ok(())
24666    }
24667}
24668///[`VkVideoEncodeH265StdFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265StdFlagBitsKHR.html)
24669#[repr(transparent)]
24670#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
24671#[doc(alias = "VkVideoEncodeH265StdFlagBitsKHR")]
24672pub struct VideoEncodeH265StdFlagBitsKHR(u32);
24673impl VideoEncodeH265StdFlagBitsKHR {
24674    #[inline]
24675    pub const fn empty() -> Self {
24676        Self(0u32)
24677    }
24678    #[inline]
24679    pub const fn from_raw(value: u32) -> Self {
24680        Self(value)
24681    }
24682    #[inline]
24683    pub const fn as_raw(self) -> u32 {
24684        self.0
24685    }
24686    #[inline]
24687    pub const fn is_empty(self) -> bool {
24688        self.0 == 0u32
24689    }
24690    #[inline]
24691    pub const fn contains(self, other: Self) -> bool {
24692        (self.0 & other.0) == other.0
24693    }
24694    ///Bit 0.
24695    pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(1u32);
24696    ///Bit 1.
24697    pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET: Self = Self(2u32);
24698    ///Bit 2.
24699    pub const SCALING_LIST_DATA_PRESENT_FLAG_SET: Self = Self(4u32);
24700    ///Bit 3.
24701    pub const PCM_ENABLED_FLAG_SET: Self = Self(8u32);
24702    ///Bit 4.
24703    pub const SPS_TEMPORAL_MVP_ENABLED_FLAG_SET: Self = Self(16u32);
24704    ///Bit 5.
24705    pub const INIT_QP_MINUS26: Self = Self(32u32);
24706    ///Bit 6.
24707    pub const WEIGHTED_PRED_FLAG_SET: Self = Self(64u32);
24708    ///Bit 7.
24709    pub const WEIGHTED_BIPRED_FLAG_SET: Self = Self(128u32);
24710    ///Bit 8.
24711    pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(256u32);
24712    ///Bit 9.
24713    pub const SIGN_DATA_HIDING_ENABLED_FLAG_SET: Self = Self(512u32);
24714    ///Bit 10.
24715    pub const TRANSFORM_SKIP_ENABLED_FLAG_SET: Self = Self(1024u32);
24716    ///Bit 11.
24717    pub const TRANSFORM_SKIP_ENABLED_FLAG_UNSET: Self = Self(2048u32);
24718    ///Bit 12.
24719    pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET: Self = Self(4096u32);
24720    ///Bit 13.
24721    pub const TRANSQUANT_BYPASS_ENABLED_FLAG_SET: Self = Self(8192u32);
24722    ///Bit 14.
24723    pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(16384u32);
24724    ///Bit 15.
24725    pub const ENTROPY_CODING_SYNC_ENABLED_FLAG_SET: Self = Self(32768u32);
24726    ///Bit 16.
24727    pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET: Self = Self(65536u32);
24728    ///Bit 17.
24729    pub const DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET: Self = Self(131072u32);
24730    ///Bit 18.
24731    pub const DEPENDENT_SLICE_SEGMENT_FLAG_SET: Self = Self(262144u32);
24732    ///Bit 19.
24733    pub const SLICE_QP_DELTA: Self = Self(524288u32);
24734    ///Bit 20.
24735    pub const DIFFERENT_SLICE_QP_DELTA: Self = Self(1048576u32);
24736}
24737impl core::ops::BitOr for VideoEncodeH265StdFlagBitsKHR {
24738    type Output = Self;
24739    #[inline]
24740    fn bitor(self, rhs: Self) -> Self {
24741        Self(self.0 | rhs.0)
24742    }
24743}
24744impl core::ops::BitOrAssign for VideoEncodeH265StdFlagBitsKHR {
24745    #[inline]
24746    fn bitor_assign(&mut self, rhs: Self) {
24747        self.0 |= rhs.0;
24748    }
24749}
24750impl core::ops::BitAnd for VideoEncodeH265StdFlagBitsKHR {
24751    type Output = Self;
24752    #[inline]
24753    fn bitand(self, rhs: Self) -> Self {
24754        Self(self.0 & rhs.0)
24755    }
24756}
24757impl core::ops::BitAndAssign for VideoEncodeH265StdFlagBitsKHR {
24758    #[inline]
24759    fn bitand_assign(&mut self, rhs: Self) {
24760        self.0 &= rhs.0;
24761    }
24762}
24763impl core::ops::BitXor for VideoEncodeH265StdFlagBitsKHR {
24764    type Output = Self;
24765    #[inline]
24766    fn bitxor(self, rhs: Self) -> Self {
24767        Self(self.0 ^ rhs.0)
24768    }
24769}
24770impl core::ops::BitXorAssign for VideoEncodeH265StdFlagBitsKHR {
24771    #[inline]
24772    fn bitxor_assign(&mut self, rhs: Self) {
24773        self.0 ^= rhs.0;
24774    }
24775}
24776impl core::ops::Not for VideoEncodeH265StdFlagBitsKHR {
24777    type Output = Self;
24778    #[inline]
24779    fn not(self) -> Self {
24780        Self(!self.0)
24781    }
24782}
24783impl core::fmt::Debug for VideoEncodeH265StdFlagBitsKHR {
24784    #[allow(unused_mut, unused_variables)]
24785    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
24786        let mut first = true;
24787        let mut remaining = self.0;
24788        if remaining & Self::SEPARATE_COLOR_PLANE_FLAG_SET.0 != 0 {
24789            if !first {
24790                f.write_str(" | ")?;
24791            }
24792            f.write_str("SEPARATE_COLOR_PLANE_FLAG_SET")?;
24793            remaining &= !Self::SEPARATE_COLOR_PLANE_FLAG_SET.0;
24794            first = false;
24795        }
24796        if remaining & Self::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET.0 != 0 {
24797            if !first {
24798                f.write_str(" | ")?;
24799            }
24800            f.write_str("SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET")?;
24801            remaining &= !Self::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET.0;
24802            first = false;
24803        }
24804        if remaining & Self::SCALING_LIST_DATA_PRESENT_FLAG_SET.0 != 0 {
24805            if !first {
24806                f.write_str(" | ")?;
24807            }
24808            f.write_str("SCALING_LIST_DATA_PRESENT_FLAG_SET")?;
24809            remaining &= !Self::SCALING_LIST_DATA_PRESENT_FLAG_SET.0;
24810            first = false;
24811        }
24812        if remaining & Self::PCM_ENABLED_FLAG_SET.0 != 0 {
24813            if !first {
24814                f.write_str(" | ")?;
24815            }
24816            f.write_str("PCM_ENABLED_FLAG_SET")?;
24817            remaining &= !Self::PCM_ENABLED_FLAG_SET.0;
24818            first = false;
24819        }
24820        if remaining & Self::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET.0 != 0 {
24821            if !first {
24822                f.write_str(" | ")?;
24823            }
24824            f.write_str("SPS_TEMPORAL_MVP_ENABLED_FLAG_SET")?;
24825            remaining &= !Self::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET.0;
24826            first = false;
24827        }
24828        if remaining & Self::INIT_QP_MINUS26.0 != 0 {
24829            if !first {
24830                f.write_str(" | ")?;
24831            }
24832            f.write_str("INIT_QP_MINUS26")?;
24833            remaining &= !Self::INIT_QP_MINUS26.0;
24834            first = false;
24835        }
24836        if remaining & Self::WEIGHTED_PRED_FLAG_SET.0 != 0 {
24837            if !first {
24838                f.write_str(" | ")?;
24839            }
24840            f.write_str("WEIGHTED_PRED_FLAG_SET")?;
24841            remaining &= !Self::WEIGHTED_PRED_FLAG_SET.0;
24842            first = false;
24843        }
24844        if remaining & Self::WEIGHTED_BIPRED_FLAG_SET.0 != 0 {
24845            if !first {
24846                f.write_str(" | ")?;
24847            }
24848            f.write_str("WEIGHTED_BIPRED_FLAG_SET")?;
24849            remaining &= !Self::WEIGHTED_BIPRED_FLAG_SET.0;
24850            first = false;
24851        }
24852        if remaining & Self::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0 != 0 {
24853            if !first {
24854                f.write_str(" | ")?;
24855            }
24856            f.write_str("LOG2_PARALLEL_MERGE_LEVEL_MINUS2")?;
24857            remaining &= !Self::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0;
24858            first = false;
24859        }
24860        if remaining & Self::SIGN_DATA_HIDING_ENABLED_FLAG_SET.0 != 0 {
24861            if !first {
24862                f.write_str(" | ")?;
24863            }
24864            f.write_str("SIGN_DATA_HIDING_ENABLED_FLAG_SET")?;
24865            remaining &= !Self::SIGN_DATA_HIDING_ENABLED_FLAG_SET.0;
24866            first = false;
24867        }
24868        if remaining & Self::TRANSFORM_SKIP_ENABLED_FLAG_SET.0 != 0 {
24869            if !first {
24870                f.write_str(" | ")?;
24871            }
24872            f.write_str("TRANSFORM_SKIP_ENABLED_FLAG_SET")?;
24873            remaining &= !Self::TRANSFORM_SKIP_ENABLED_FLAG_SET.0;
24874            first = false;
24875        }
24876        if remaining & Self::TRANSFORM_SKIP_ENABLED_FLAG_UNSET.0 != 0 {
24877            if !first {
24878                f.write_str(" | ")?;
24879            }
24880            f.write_str("TRANSFORM_SKIP_ENABLED_FLAG_UNSET")?;
24881            remaining &= !Self::TRANSFORM_SKIP_ENABLED_FLAG_UNSET.0;
24882            first = false;
24883        }
24884        if remaining & Self::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET.0 != 0 {
24885            if !first {
24886                f.write_str(" | ")?;
24887            }
24888            f.write_str("PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET")?;
24889            remaining &= !Self::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET.0;
24890            first = false;
24891        }
24892        if remaining & Self::TRANSQUANT_BYPASS_ENABLED_FLAG_SET.0 != 0 {
24893            if !first {
24894                f.write_str(" | ")?;
24895            }
24896            f.write_str("TRANSQUANT_BYPASS_ENABLED_FLAG_SET")?;
24897            remaining &= !Self::TRANSQUANT_BYPASS_ENABLED_FLAG_SET.0;
24898            first = false;
24899        }
24900        if remaining & Self::CONSTRAINED_INTRA_PRED_FLAG_SET.0 != 0 {
24901            if !first {
24902                f.write_str(" | ")?;
24903            }
24904            f.write_str("CONSTRAINED_INTRA_PRED_FLAG_SET")?;
24905            remaining &= !Self::CONSTRAINED_INTRA_PRED_FLAG_SET.0;
24906            first = false;
24907        }
24908        if remaining & Self::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET.0 != 0 {
24909            if !first {
24910                f.write_str(" | ")?;
24911            }
24912            f.write_str("ENTROPY_CODING_SYNC_ENABLED_FLAG_SET")?;
24913            remaining &= !Self::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET.0;
24914            first = false;
24915        }
24916        if remaining & Self::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET.0 != 0 {
24917            if !first {
24918                f.write_str(" | ")?;
24919            }
24920            f.write_str("DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET")?;
24921            remaining &= !Self::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET.0;
24922            first = false;
24923        }
24924        if remaining & Self::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET.0 != 0 {
24925            if !first {
24926                f.write_str(" | ")?;
24927            }
24928            f.write_str("DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET")?;
24929            remaining &= !Self::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET.0;
24930            first = false;
24931        }
24932        if remaining & Self::DEPENDENT_SLICE_SEGMENT_FLAG_SET.0 != 0 {
24933            if !first {
24934                f.write_str(" | ")?;
24935            }
24936            f.write_str("DEPENDENT_SLICE_SEGMENT_FLAG_SET")?;
24937            remaining &= !Self::DEPENDENT_SLICE_SEGMENT_FLAG_SET.0;
24938            first = false;
24939        }
24940        if remaining & Self::SLICE_QP_DELTA.0 != 0 {
24941            if !first {
24942                f.write_str(" | ")?;
24943            }
24944            f.write_str("SLICE_QP_DELTA")?;
24945            remaining &= !Self::SLICE_QP_DELTA.0;
24946            first = false;
24947        }
24948        if remaining & Self::DIFFERENT_SLICE_QP_DELTA.0 != 0 {
24949            if !first {
24950                f.write_str(" | ")?;
24951            }
24952            f.write_str("DIFFERENT_SLICE_QP_DELTA")?;
24953            remaining &= !Self::DIFFERENT_SLICE_QP_DELTA.0;
24954            first = false;
24955        }
24956        if remaining != 0u32 {
24957            if !first {
24958                f.write_str(" | ")?;
24959            }
24960            write!(f, "{:#x}", remaining)?;
24961        } else if first {
24962            f.write_str("(empty)")?;
24963        }
24964        Ok(())
24965    }
24966}
24967///[`VkVideoEncodeH265TransformBlockSizeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265TransformBlockSizeFlagBitsKHR.html)
24968#[repr(transparent)]
24969#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
24970#[doc(alias = "VkVideoEncodeH265TransformBlockSizeFlagBitsKHR")]
24971pub struct VideoEncodeH265TransformBlockSizeFlagBitsKHR(u32);
24972impl VideoEncodeH265TransformBlockSizeFlagBitsKHR {
24973    #[inline]
24974    pub const fn empty() -> Self {
24975        Self(0u32)
24976    }
24977    #[inline]
24978    pub const fn from_raw(value: u32) -> Self {
24979        Self(value)
24980    }
24981    #[inline]
24982    pub const fn as_raw(self) -> u32 {
24983        self.0
24984    }
24985    #[inline]
24986    pub const fn is_empty(self) -> bool {
24987        self.0 == 0u32
24988    }
24989    #[inline]
24990    pub const fn contains(self, other: Self) -> bool {
24991        (self.0 & other.0) == other.0
24992    }
24993    ///Bit 0.
24994    pub const _4: Self = Self(1u32);
24995    ///Bit 1.
24996    pub const _8: Self = Self(2u32);
24997    ///Bit 2.
24998    pub const _16: Self = Self(4u32);
24999    ///Bit 3.
25000    pub const _32: Self = Self(8u32);
25001}
25002impl core::ops::BitOr for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25003    type Output = Self;
25004    #[inline]
25005    fn bitor(self, rhs: Self) -> Self {
25006        Self(self.0 | rhs.0)
25007    }
25008}
25009impl core::ops::BitOrAssign for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25010    #[inline]
25011    fn bitor_assign(&mut self, rhs: Self) {
25012        self.0 |= rhs.0;
25013    }
25014}
25015impl core::ops::BitAnd for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25016    type Output = Self;
25017    #[inline]
25018    fn bitand(self, rhs: Self) -> Self {
25019        Self(self.0 & rhs.0)
25020    }
25021}
25022impl core::ops::BitAndAssign for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25023    #[inline]
25024    fn bitand_assign(&mut self, rhs: Self) {
25025        self.0 &= rhs.0;
25026    }
25027}
25028impl core::ops::BitXor for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25029    type Output = Self;
25030    #[inline]
25031    fn bitxor(self, rhs: Self) -> Self {
25032        Self(self.0 ^ rhs.0)
25033    }
25034}
25035impl core::ops::BitXorAssign for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25036    #[inline]
25037    fn bitxor_assign(&mut self, rhs: Self) {
25038        self.0 ^= rhs.0;
25039    }
25040}
25041impl core::ops::Not for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25042    type Output = Self;
25043    #[inline]
25044    fn not(self) -> Self {
25045        Self(!self.0)
25046    }
25047}
25048impl core::fmt::Debug for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
25049    #[allow(unused_mut, unused_variables)]
25050    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25051        let mut first = true;
25052        let mut remaining = self.0;
25053        if remaining & Self::_4.0 != 0 {
25054            if !first {
25055                f.write_str(" | ")?;
25056            }
25057            f.write_str("_4")?;
25058            remaining &= !Self::_4.0;
25059            first = false;
25060        }
25061        if remaining & Self::_8.0 != 0 {
25062            if !first {
25063                f.write_str(" | ")?;
25064            }
25065            f.write_str("_8")?;
25066            remaining &= !Self::_8.0;
25067            first = false;
25068        }
25069        if remaining & Self::_16.0 != 0 {
25070            if !first {
25071                f.write_str(" | ")?;
25072            }
25073            f.write_str("_16")?;
25074            remaining &= !Self::_16.0;
25075            first = false;
25076        }
25077        if remaining & Self::_32.0 != 0 {
25078            if !first {
25079                f.write_str(" | ")?;
25080            }
25081            f.write_str("_32")?;
25082            remaining &= !Self::_32.0;
25083            first = false;
25084        }
25085        if remaining != 0u32 {
25086            if !first {
25087                f.write_str(" | ")?;
25088            }
25089            write!(f, "{:#x}", remaining)?;
25090        } else if first {
25091            f.write_str("(empty)")?;
25092        }
25093        Ok(())
25094    }
25095}
25096///[`VkVideoEncodeIntraRefreshModeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshModeFlagBitsKHR.html)
25097#[repr(transparent)]
25098#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
25099#[doc(alias = "VkVideoEncodeIntraRefreshModeFlagBitsKHR")]
25100pub struct VideoEncodeIntraRefreshModeFlagBitsKHR(u32);
25101impl VideoEncodeIntraRefreshModeFlagBitsKHR {
25102    #[inline]
25103    pub const fn empty() -> Self {
25104        Self(0u32)
25105    }
25106    #[inline]
25107    pub const fn from_raw(value: u32) -> Self {
25108        Self(value)
25109    }
25110    #[inline]
25111    pub const fn as_raw(self) -> u32 {
25112        self.0
25113    }
25114    #[inline]
25115    pub const fn is_empty(self) -> bool {
25116        self.0 == 0u32
25117    }
25118    #[inline]
25119    pub const fn contains(self, other: Self) -> bool {
25120        (self.0 & other.0) == other.0
25121    }
25122    pub const NONE: Self = Self(0u32);
25123    ///Bit 0.
25124    pub const PER_PICTURE_PARTITION: Self = Self(1u32);
25125    ///Bit 1.
25126    pub const BLOCK_BASED: Self = Self(2u32);
25127    ///Bit 2.
25128    pub const BLOCK_ROW_BASED: Self = Self(4u32);
25129    ///Bit 3.
25130    pub const BLOCK_COLUMN_BASED: Self = Self(8u32);
25131}
25132impl core::ops::BitOr for VideoEncodeIntraRefreshModeFlagBitsKHR {
25133    type Output = Self;
25134    #[inline]
25135    fn bitor(self, rhs: Self) -> Self {
25136        Self(self.0 | rhs.0)
25137    }
25138}
25139impl core::ops::BitOrAssign for VideoEncodeIntraRefreshModeFlagBitsKHR {
25140    #[inline]
25141    fn bitor_assign(&mut self, rhs: Self) {
25142        self.0 |= rhs.0;
25143    }
25144}
25145impl core::ops::BitAnd for VideoEncodeIntraRefreshModeFlagBitsKHR {
25146    type Output = Self;
25147    #[inline]
25148    fn bitand(self, rhs: Self) -> Self {
25149        Self(self.0 & rhs.0)
25150    }
25151}
25152impl core::ops::BitAndAssign for VideoEncodeIntraRefreshModeFlagBitsKHR {
25153    #[inline]
25154    fn bitand_assign(&mut self, rhs: Self) {
25155        self.0 &= rhs.0;
25156    }
25157}
25158impl core::ops::BitXor for VideoEncodeIntraRefreshModeFlagBitsKHR {
25159    type Output = Self;
25160    #[inline]
25161    fn bitxor(self, rhs: Self) -> Self {
25162        Self(self.0 ^ rhs.0)
25163    }
25164}
25165impl core::ops::BitXorAssign for VideoEncodeIntraRefreshModeFlagBitsKHR {
25166    #[inline]
25167    fn bitxor_assign(&mut self, rhs: Self) {
25168        self.0 ^= rhs.0;
25169    }
25170}
25171impl core::ops::Not for VideoEncodeIntraRefreshModeFlagBitsKHR {
25172    type Output = Self;
25173    #[inline]
25174    fn not(self) -> Self {
25175        Self(!self.0)
25176    }
25177}
25178impl core::fmt::Debug for VideoEncodeIntraRefreshModeFlagBitsKHR {
25179    #[allow(unused_mut, unused_variables)]
25180    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25181        let mut first = true;
25182        let mut remaining = self.0;
25183        if remaining & Self::PER_PICTURE_PARTITION.0 != 0 {
25184            if !first {
25185                f.write_str(" | ")?;
25186            }
25187            f.write_str("PER_PICTURE_PARTITION")?;
25188            remaining &= !Self::PER_PICTURE_PARTITION.0;
25189            first = false;
25190        }
25191        if remaining & Self::BLOCK_BASED.0 != 0 {
25192            if !first {
25193                f.write_str(" | ")?;
25194            }
25195            f.write_str("BLOCK_BASED")?;
25196            remaining &= !Self::BLOCK_BASED.0;
25197            first = false;
25198        }
25199        if remaining & Self::BLOCK_ROW_BASED.0 != 0 {
25200            if !first {
25201                f.write_str(" | ")?;
25202            }
25203            f.write_str("BLOCK_ROW_BASED")?;
25204            remaining &= !Self::BLOCK_ROW_BASED.0;
25205            first = false;
25206        }
25207        if remaining & Self::BLOCK_COLUMN_BASED.0 != 0 {
25208            if !first {
25209                f.write_str(" | ")?;
25210            }
25211            f.write_str("BLOCK_COLUMN_BASED")?;
25212            remaining &= !Self::BLOCK_COLUMN_BASED.0;
25213            first = false;
25214        }
25215        if remaining != 0u32 {
25216            if !first {
25217                f.write_str(" | ")?;
25218            }
25219            write!(f, "{:#x}", remaining)?;
25220        } else if first {
25221            f.write_str("(empty)")?;
25222        }
25223        Ok(())
25224    }
25225}
25226///[`VkVideoEncodeRateControlModeFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html)
25227#[repr(transparent)]
25228#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
25229#[doc(alias = "VkVideoEncodeRateControlModeFlagBitsKHR")]
25230pub struct VideoEncodeRateControlModeFlagBitsKHR(u32);
25231impl VideoEncodeRateControlModeFlagBitsKHR {
25232    #[inline]
25233    pub const fn empty() -> Self {
25234        Self(0u32)
25235    }
25236    #[inline]
25237    pub const fn from_raw(value: u32) -> Self {
25238        Self(value)
25239    }
25240    #[inline]
25241    pub const fn as_raw(self) -> u32 {
25242        self.0
25243    }
25244    #[inline]
25245    pub const fn is_empty(self) -> bool {
25246        self.0 == 0u32
25247    }
25248    #[inline]
25249    pub const fn contains(self, other: Self) -> bool {
25250        (self.0 & other.0) == other.0
25251    }
25252    pub const DEFAULT: Self = Self(0u32);
25253    ///Bit 0.
25254    pub const DISABLED: Self = Self(1u32);
25255    ///Bit 1.
25256    pub const CBR: Self = Self(2u32);
25257    ///Bit 2.
25258    pub const VBR: Self = Self(4u32);
25259}
25260impl core::ops::BitOr for VideoEncodeRateControlModeFlagBitsKHR {
25261    type Output = Self;
25262    #[inline]
25263    fn bitor(self, rhs: Self) -> Self {
25264        Self(self.0 | rhs.0)
25265    }
25266}
25267impl core::ops::BitOrAssign for VideoEncodeRateControlModeFlagBitsKHR {
25268    #[inline]
25269    fn bitor_assign(&mut self, rhs: Self) {
25270        self.0 |= rhs.0;
25271    }
25272}
25273impl core::ops::BitAnd for VideoEncodeRateControlModeFlagBitsKHR {
25274    type Output = Self;
25275    #[inline]
25276    fn bitand(self, rhs: Self) -> Self {
25277        Self(self.0 & rhs.0)
25278    }
25279}
25280impl core::ops::BitAndAssign for VideoEncodeRateControlModeFlagBitsKHR {
25281    #[inline]
25282    fn bitand_assign(&mut self, rhs: Self) {
25283        self.0 &= rhs.0;
25284    }
25285}
25286impl core::ops::BitXor for VideoEncodeRateControlModeFlagBitsKHR {
25287    type Output = Self;
25288    #[inline]
25289    fn bitxor(self, rhs: Self) -> Self {
25290        Self(self.0 ^ rhs.0)
25291    }
25292}
25293impl core::ops::BitXorAssign for VideoEncodeRateControlModeFlagBitsKHR {
25294    #[inline]
25295    fn bitxor_assign(&mut self, rhs: Self) {
25296        self.0 ^= rhs.0;
25297    }
25298}
25299impl core::ops::Not for VideoEncodeRateControlModeFlagBitsKHR {
25300    type Output = Self;
25301    #[inline]
25302    fn not(self) -> Self {
25303        Self(!self.0)
25304    }
25305}
25306impl core::fmt::Debug for VideoEncodeRateControlModeFlagBitsKHR {
25307    #[allow(unused_mut, unused_variables)]
25308    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25309        let mut first = true;
25310        let mut remaining = self.0;
25311        if remaining & Self::DISABLED.0 != 0 {
25312            if !first {
25313                f.write_str(" | ")?;
25314            }
25315            f.write_str("DISABLED")?;
25316            remaining &= !Self::DISABLED.0;
25317            first = false;
25318        }
25319        if remaining & Self::CBR.0 != 0 {
25320            if !first {
25321                f.write_str(" | ")?;
25322            }
25323            f.write_str("CBR")?;
25324            remaining &= !Self::CBR.0;
25325            first = false;
25326        }
25327        if remaining & Self::VBR.0 != 0 {
25328            if !first {
25329                f.write_str(" | ")?;
25330            }
25331            f.write_str("VBR")?;
25332            remaining &= !Self::VBR.0;
25333            first = false;
25334        }
25335        if remaining != 0u32 {
25336            if !first {
25337                f.write_str(" | ")?;
25338            }
25339            write!(f, "{:#x}", remaining)?;
25340        } else if first {
25341            f.write_str("(empty)")?;
25342        }
25343        Ok(())
25344    }
25345}
25346///[`VkVideoEncodeRgbChromaOffsetFlagBitsVALVE`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbChromaOffsetFlagBitsVALVE.html)
25347#[repr(transparent)]
25348#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
25349#[doc(alias = "VkVideoEncodeRgbChromaOffsetFlagBitsVALVE")]
25350pub struct VideoEncodeRgbChromaOffsetFlagBitsVALVE(u32);
25351impl VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25352    #[inline]
25353    pub const fn empty() -> Self {
25354        Self(0u32)
25355    }
25356    #[inline]
25357    pub const fn from_raw(value: u32) -> Self {
25358        Self(value)
25359    }
25360    #[inline]
25361    pub const fn as_raw(self) -> u32 {
25362        self.0
25363    }
25364    #[inline]
25365    pub const fn is_empty(self) -> bool {
25366        self.0 == 0u32
25367    }
25368    #[inline]
25369    pub const fn contains(self, other: Self) -> bool {
25370        (self.0 & other.0) == other.0
25371    }
25372    ///Bit 0.
25373    pub const COSITED_EVEN_BIT: Self = Self(1u32);
25374    ///Bit 1.
25375    pub const MIDPOINT_BIT: Self = Self(2u32);
25376}
25377impl core::ops::BitOr for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25378    type Output = Self;
25379    #[inline]
25380    fn bitor(self, rhs: Self) -> Self {
25381        Self(self.0 | rhs.0)
25382    }
25383}
25384impl core::ops::BitOrAssign for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25385    #[inline]
25386    fn bitor_assign(&mut self, rhs: Self) {
25387        self.0 |= rhs.0;
25388    }
25389}
25390impl core::ops::BitAnd for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25391    type Output = Self;
25392    #[inline]
25393    fn bitand(self, rhs: Self) -> Self {
25394        Self(self.0 & rhs.0)
25395    }
25396}
25397impl core::ops::BitAndAssign for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25398    #[inline]
25399    fn bitand_assign(&mut self, rhs: Self) {
25400        self.0 &= rhs.0;
25401    }
25402}
25403impl core::ops::BitXor for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25404    type Output = Self;
25405    #[inline]
25406    fn bitxor(self, rhs: Self) -> Self {
25407        Self(self.0 ^ rhs.0)
25408    }
25409}
25410impl core::ops::BitXorAssign for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25411    #[inline]
25412    fn bitxor_assign(&mut self, rhs: Self) {
25413        self.0 ^= rhs.0;
25414    }
25415}
25416impl core::ops::Not for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25417    type Output = Self;
25418    #[inline]
25419    fn not(self) -> Self {
25420        Self(!self.0)
25421    }
25422}
25423impl core::fmt::Debug for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
25424    #[allow(unused_mut, unused_variables)]
25425    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25426        let mut first = true;
25427        let mut remaining = self.0;
25428        if remaining & Self::COSITED_EVEN_BIT.0 != 0 {
25429            if !first {
25430                f.write_str(" | ")?;
25431            }
25432            f.write_str("COSITED_EVEN_BIT")?;
25433            remaining &= !Self::COSITED_EVEN_BIT.0;
25434            first = false;
25435        }
25436        if remaining & Self::MIDPOINT_BIT.0 != 0 {
25437            if !first {
25438                f.write_str(" | ")?;
25439            }
25440            f.write_str("MIDPOINT_BIT")?;
25441            remaining &= !Self::MIDPOINT_BIT.0;
25442            first = false;
25443        }
25444        if remaining != 0u32 {
25445            if !first {
25446                f.write_str(" | ")?;
25447            }
25448            write!(f, "{:#x}", remaining)?;
25449        } else if first {
25450            f.write_str("(empty)")?;
25451        }
25452        Ok(())
25453    }
25454}
25455///[`VkVideoEncodeRgbModelConversionFlagBitsVALVE`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbModelConversionFlagBitsVALVE.html)
25456#[repr(transparent)]
25457#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
25458#[doc(alias = "VkVideoEncodeRgbModelConversionFlagBitsVALVE")]
25459pub struct VideoEncodeRgbModelConversionFlagBitsVALVE(u32);
25460impl VideoEncodeRgbModelConversionFlagBitsVALVE {
25461    #[inline]
25462    pub const fn empty() -> Self {
25463        Self(0u32)
25464    }
25465    #[inline]
25466    pub const fn from_raw(value: u32) -> Self {
25467        Self(value)
25468    }
25469    #[inline]
25470    pub const fn as_raw(self) -> u32 {
25471        self.0
25472    }
25473    #[inline]
25474    pub const fn is_empty(self) -> bool {
25475        self.0 == 0u32
25476    }
25477    #[inline]
25478    pub const fn contains(self, other: Self) -> bool {
25479        (self.0 & other.0) == other.0
25480    }
25481    ///Bit 0.
25482    pub const RGB_IDENTITY_BIT: Self = Self(1u32);
25483    ///Bit 1.
25484    pub const YCBCR_IDENTITY_BIT: Self = Self(2u32);
25485    ///Bit 2.
25486    pub const YCBCR_709_BIT: Self = Self(4u32);
25487    ///Bit 3.
25488    pub const YCBCR_601_BIT: Self = Self(8u32);
25489    ///Bit 4.
25490    pub const YCBCR_2020_BIT: Self = Self(16u32);
25491}
25492impl core::ops::BitOr for VideoEncodeRgbModelConversionFlagBitsVALVE {
25493    type Output = Self;
25494    #[inline]
25495    fn bitor(self, rhs: Self) -> Self {
25496        Self(self.0 | rhs.0)
25497    }
25498}
25499impl core::ops::BitOrAssign for VideoEncodeRgbModelConversionFlagBitsVALVE {
25500    #[inline]
25501    fn bitor_assign(&mut self, rhs: Self) {
25502        self.0 |= rhs.0;
25503    }
25504}
25505impl core::ops::BitAnd for VideoEncodeRgbModelConversionFlagBitsVALVE {
25506    type Output = Self;
25507    #[inline]
25508    fn bitand(self, rhs: Self) -> Self {
25509        Self(self.0 & rhs.0)
25510    }
25511}
25512impl core::ops::BitAndAssign for VideoEncodeRgbModelConversionFlagBitsVALVE {
25513    #[inline]
25514    fn bitand_assign(&mut self, rhs: Self) {
25515        self.0 &= rhs.0;
25516    }
25517}
25518impl core::ops::BitXor for VideoEncodeRgbModelConversionFlagBitsVALVE {
25519    type Output = Self;
25520    #[inline]
25521    fn bitxor(self, rhs: Self) -> Self {
25522        Self(self.0 ^ rhs.0)
25523    }
25524}
25525impl core::ops::BitXorAssign for VideoEncodeRgbModelConversionFlagBitsVALVE {
25526    #[inline]
25527    fn bitxor_assign(&mut self, rhs: Self) {
25528        self.0 ^= rhs.0;
25529    }
25530}
25531impl core::ops::Not for VideoEncodeRgbModelConversionFlagBitsVALVE {
25532    type Output = Self;
25533    #[inline]
25534    fn not(self) -> Self {
25535        Self(!self.0)
25536    }
25537}
25538impl core::fmt::Debug for VideoEncodeRgbModelConversionFlagBitsVALVE {
25539    #[allow(unused_mut, unused_variables)]
25540    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25541        let mut first = true;
25542        let mut remaining = self.0;
25543        if remaining & Self::RGB_IDENTITY_BIT.0 != 0 {
25544            if !first {
25545                f.write_str(" | ")?;
25546            }
25547            f.write_str("RGB_IDENTITY_BIT")?;
25548            remaining &= !Self::RGB_IDENTITY_BIT.0;
25549            first = false;
25550        }
25551        if remaining & Self::YCBCR_IDENTITY_BIT.0 != 0 {
25552            if !first {
25553                f.write_str(" | ")?;
25554            }
25555            f.write_str("YCBCR_IDENTITY_BIT")?;
25556            remaining &= !Self::YCBCR_IDENTITY_BIT.0;
25557            first = false;
25558        }
25559        if remaining & Self::YCBCR_709_BIT.0 != 0 {
25560            if !first {
25561                f.write_str(" | ")?;
25562            }
25563            f.write_str("YCBCR_709_BIT")?;
25564            remaining &= !Self::YCBCR_709_BIT.0;
25565            first = false;
25566        }
25567        if remaining & Self::YCBCR_601_BIT.0 != 0 {
25568            if !first {
25569                f.write_str(" | ")?;
25570            }
25571            f.write_str("YCBCR_601_BIT")?;
25572            remaining &= !Self::YCBCR_601_BIT.0;
25573            first = false;
25574        }
25575        if remaining & Self::YCBCR_2020_BIT.0 != 0 {
25576            if !first {
25577                f.write_str(" | ")?;
25578            }
25579            f.write_str("YCBCR_2020_BIT")?;
25580            remaining &= !Self::YCBCR_2020_BIT.0;
25581            first = false;
25582        }
25583        if remaining != 0u32 {
25584            if !first {
25585                f.write_str(" | ")?;
25586            }
25587            write!(f, "{:#x}", remaining)?;
25588        } else if first {
25589            f.write_str("(empty)")?;
25590        }
25591        Ok(())
25592    }
25593}
25594///[`VkVideoEncodeRgbRangeCompressionFlagBitsVALVE`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbRangeCompressionFlagBitsVALVE.html)
25595#[repr(transparent)]
25596#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
25597#[doc(alias = "VkVideoEncodeRgbRangeCompressionFlagBitsVALVE")]
25598pub struct VideoEncodeRgbRangeCompressionFlagBitsVALVE(u32);
25599impl VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25600    #[inline]
25601    pub const fn empty() -> Self {
25602        Self(0u32)
25603    }
25604    #[inline]
25605    pub const fn from_raw(value: u32) -> Self {
25606        Self(value)
25607    }
25608    #[inline]
25609    pub const fn as_raw(self) -> u32 {
25610        self.0
25611    }
25612    #[inline]
25613    pub const fn is_empty(self) -> bool {
25614        self.0 == 0u32
25615    }
25616    #[inline]
25617    pub const fn contains(self, other: Self) -> bool {
25618        (self.0 & other.0) == other.0
25619    }
25620    ///Bit 0.
25621    pub const FULL_RANGE_BIT: Self = Self(1u32);
25622    ///Bit 1.
25623    pub const NARROW_RANGE_BIT: Self = Self(2u32);
25624}
25625impl core::ops::BitOr for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25626    type Output = Self;
25627    #[inline]
25628    fn bitor(self, rhs: Self) -> Self {
25629        Self(self.0 | rhs.0)
25630    }
25631}
25632impl core::ops::BitOrAssign for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25633    #[inline]
25634    fn bitor_assign(&mut self, rhs: Self) {
25635        self.0 |= rhs.0;
25636    }
25637}
25638impl core::ops::BitAnd for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25639    type Output = Self;
25640    #[inline]
25641    fn bitand(self, rhs: Self) -> Self {
25642        Self(self.0 & rhs.0)
25643    }
25644}
25645impl core::ops::BitAndAssign for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25646    #[inline]
25647    fn bitand_assign(&mut self, rhs: Self) {
25648        self.0 &= rhs.0;
25649    }
25650}
25651impl core::ops::BitXor for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25652    type Output = Self;
25653    #[inline]
25654    fn bitxor(self, rhs: Self) -> Self {
25655        Self(self.0 ^ rhs.0)
25656    }
25657}
25658impl core::ops::BitXorAssign for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25659    #[inline]
25660    fn bitxor_assign(&mut self, rhs: Self) {
25661        self.0 ^= rhs.0;
25662    }
25663}
25664impl core::ops::Not for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25665    type Output = Self;
25666    #[inline]
25667    fn not(self) -> Self {
25668        Self(!self.0)
25669    }
25670}
25671impl core::fmt::Debug for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
25672    #[allow(unused_mut, unused_variables)]
25673    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25674        let mut first = true;
25675        let mut remaining = self.0;
25676        if remaining & Self::FULL_RANGE_BIT.0 != 0 {
25677            if !first {
25678                f.write_str(" | ")?;
25679            }
25680            f.write_str("FULL_RANGE_BIT")?;
25681            remaining &= !Self::FULL_RANGE_BIT.0;
25682            first = false;
25683        }
25684        if remaining & Self::NARROW_RANGE_BIT.0 != 0 {
25685            if !first {
25686                f.write_str(" | ")?;
25687            }
25688            f.write_str("NARROW_RANGE_BIT")?;
25689            remaining &= !Self::NARROW_RANGE_BIT.0;
25690            first = false;
25691        }
25692        if remaining != 0u32 {
25693            if !first {
25694                f.write_str(" | ")?;
25695            }
25696            write!(f, "{:#x}", remaining)?;
25697        } else if first {
25698            f.write_str("(empty)")?;
25699        }
25700        Ok(())
25701    }
25702}
25703///[`VkVideoEncodeUsageFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeUsageFlagBitsKHR.html)
25704#[repr(transparent)]
25705#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
25706#[doc(alias = "VkVideoEncodeUsageFlagBitsKHR")]
25707pub struct VideoEncodeUsageFlagBitsKHR(u32);
25708impl VideoEncodeUsageFlagBitsKHR {
25709    #[inline]
25710    pub const fn empty() -> Self {
25711        Self(0u32)
25712    }
25713    #[inline]
25714    pub const fn from_raw(value: u32) -> Self {
25715        Self(value)
25716    }
25717    #[inline]
25718    pub const fn as_raw(self) -> u32 {
25719        self.0
25720    }
25721    #[inline]
25722    pub const fn is_empty(self) -> bool {
25723        self.0 == 0u32
25724    }
25725    #[inline]
25726    pub const fn contains(self, other: Self) -> bool {
25727        (self.0 & other.0) == other.0
25728    }
25729    pub const DEFAULT: Self = Self(0u32);
25730    ///Bit 0.
25731    pub const TRANSCODING: Self = Self(1u32);
25732    ///Bit 1.
25733    pub const STREAMING: Self = Self(2u32);
25734    ///Bit 2.
25735    pub const RECORDING: Self = Self(4u32);
25736    ///Bit 3.
25737    pub const CONFERENCING: Self = Self(8u32);
25738}
25739impl core::ops::BitOr for VideoEncodeUsageFlagBitsKHR {
25740    type Output = Self;
25741    #[inline]
25742    fn bitor(self, rhs: Self) -> Self {
25743        Self(self.0 | rhs.0)
25744    }
25745}
25746impl core::ops::BitOrAssign for VideoEncodeUsageFlagBitsKHR {
25747    #[inline]
25748    fn bitor_assign(&mut self, rhs: Self) {
25749        self.0 |= rhs.0;
25750    }
25751}
25752impl core::ops::BitAnd for VideoEncodeUsageFlagBitsKHR {
25753    type Output = Self;
25754    #[inline]
25755    fn bitand(self, rhs: Self) -> Self {
25756        Self(self.0 & rhs.0)
25757    }
25758}
25759impl core::ops::BitAndAssign for VideoEncodeUsageFlagBitsKHR {
25760    #[inline]
25761    fn bitand_assign(&mut self, rhs: Self) {
25762        self.0 &= rhs.0;
25763    }
25764}
25765impl core::ops::BitXor for VideoEncodeUsageFlagBitsKHR {
25766    type Output = Self;
25767    #[inline]
25768    fn bitxor(self, rhs: Self) -> Self {
25769        Self(self.0 ^ rhs.0)
25770    }
25771}
25772impl core::ops::BitXorAssign for VideoEncodeUsageFlagBitsKHR {
25773    #[inline]
25774    fn bitxor_assign(&mut self, rhs: Self) {
25775        self.0 ^= rhs.0;
25776    }
25777}
25778impl core::ops::Not for VideoEncodeUsageFlagBitsKHR {
25779    type Output = Self;
25780    #[inline]
25781    fn not(self) -> Self {
25782        Self(!self.0)
25783    }
25784}
25785impl core::fmt::Debug for VideoEncodeUsageFlagBitsKHR {
25786    #[allow(unused_mut, unused_variables)]
25787    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25788        let mut first = true;
25789        let mut remaining = self.0;
25790        if remaining & Self::TRANSCODING.0 != 0 {
25791            if !first {
25792                f.write_str(" | ")?;
25793            }
25794            f.write_str("TRANSCODING")?;
25795            remaining &= !Self::TRANSCODING.0;
25796            first = false;
25797        }
25798        if remaining & Self::STREAMING.0 != 0 {
25799            if !first {
25800                f.write_str(" | ")?;
25801            }
25802            f.write_str("STREAMING")?;
25803            remaining &= !Self::STREAMING.0;
25804            first = false;
25805        }
25806        if remaining & Self::RECORDING.0 != 0 {
25807            if !first {
25808                f.write_str(" | ")?;
25809            }
25810            f.write_str("RECORDING")?;
25811            remaining &= !Self::RECORDING.0;
25812            first = false;
25813        }
25814        if remaining & Self::CONFERENCING.0 != 0 {
25815            if !first {
25816                f.write_str(" | ")?;
25817            }
25818            f.write_str("CONFERENCING")?;
25819            remaining &= !Self::CONFERENCING.0;
25820            first = false;
25821        }
25822        if remaining != 0u32 {
25823            if !first {
25824                f.write_str(" | ")?;
25825            }
25826            write!(f, "{:#x}", remaining)?;
25827        } else if first {
25828            f.write_str("(empty)")?;
25829        }
25830        Ok(())
25831    }
25832}
25833///[`VkVideoSessionCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionCreateFlagBitsKHR.html)
25834#[repr(transparent)]
25835#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
25836#[doc(alias = "VkVideoSessionCreateFlagBitsKHR")]
25837pub struct VideoSessionCreateFlagBitsKHR(u32);
25838impl VideoSessionCreateFlagBitsKHR {
25839    #[inline]
25840    pub const fn empty() -> Self {
25841        Self(0u32)
25842    }
25843    #[inline]
25844    pub const fn from_raw(value: u32) -> Self {
25845        Self(value)
25846    }
25847    #[inline]
25848    pub const fn as_raw(self) -> u32 {
25849        self.0
25850    }
25851    #[inline]
25852    pub const fn is_empty(self) -> bool {
25853        self.0 == 0u32
25854    }
25855    #[inline]
25856    pub const fn contains(self, other: Self) -> bool {
25857        (self.0 & other.0) == other.0
25858    }
25859    ///Bit 0.
25860    pub const PROTECTED_CONTENT: Self = Self(1u32);
25861    ///Bit 1.
25862    pub const ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS: Self = Self(2u32);
25863    ///Bit 2.
25864    pub const INLINE_QUERIES: Self = Self(4u32);
25865    ///Bit 3.
25866    pub const ALLOW_ENCODE_QUANTIZATION_DELTA_MAP: Self = Self(8u32);
25867    ///Bit 4.
25868    pub const ALLOW_ENCODE_EMPHASIS_MAP: Self = Self(16u32);
25869    ///Bit 5.
25870    pub const INLINE_SESSION_PARAMETERS: Self = Self(32u32);
25871}
25872impl core::ops::BitOr for VideoSessionCreateFlagBitsKHR {
25873    type Output = Self;
25874    #[inline]
25875    fn bitor(self, rhs: Self) -> Self {
25876        Self(self.0 | rhs.0)
25877    }
25878}
25879impl core::ops::BitOrAssign for VideoSessionCreateFlagBitsKHR {
25880    #[inline]
25881    fn bitor_assign(&mut self, rhs: Self) {
25882        self.0 |= rhs.0;
25883    }
25884}
25885impl core::ops::BitAnd for VideoSessionCreateFlagBitsKHR {
25886    type Output = Self;
25887    #[inline]
25888    fn bitand(self, rhs: Self) -> Self {
25889        Self(self.0 & rhs.0)
25890    }
25891}
25892impl core::ops::BitAndAssign for VideoSessionCreateFlagBitsKHR {
25893    #[inline]
25894    fn bitand_assign(&mut self, rhs: Self) {
25895        self.0 &= rhs.0;
25896    }
25897}
25898impl core::ops::BitXor for VideoSessionCreateFlagBitsKHR {
25899    type Output = Self;
25900    #[inline]
25901    fn bitxor(self, rhs: Self) -> Self {
25902        Self(self.0 ^ rhs.0)
25903    }
25904}
25905impl core::ops::BitXorAssign for VideoSessionCreateFlagBitsKHR {
25906    #[inline]
25907    fn bitxor_assign(&mut self, rhs: Self) {
25908        self.0 ^= rhs.0;
25909    }
25910}
25911impl core::ops::Not for VideoSessionCreateFlagBitsKHR {
25912    type Output = Self;
25913    #[inline]
25914    fn not(self) -> Self {
25915        Self(!self.0)
25916    }
25917}
25918impl core::fmt::Debug for VideoSessionCreateFlagBitsKHR {
25919    #[allow(unused_mut, unused_variables)]
25920    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
25921        let mut first = true;
25922        let mut remaining = self.0;
25923        if remaining & Self::PROTECTED_CONTENT.0 != 0 {
25924            if !first {
25925                f.write_str(" | ")?;
25926            }
25927            f.write_str("PROTECTED_CONTENT")?;
25928            remaining &= !Self::PROTECTED_CONTENT.0;
25929            first = false;
25930        }
25931        if remaining & Self::ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS.0 != 0 {
25932            if !first {
25933                f.write_str(" | ")?;
25934            }
25935            f.write_str("ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS")?;
25936            remaining &= !Self::ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS.0;
25937            first = false;
25938        }
25939        if remaining & Self::INLINE_QUERIES.0 != 0 {
25940            if !first {
25941                f.write_str(" | ")?;
25942            }
25943            f.write_str("INLINE_QUERIES")?;
25944            remaining &= !Self::INLINE_QUERIES.0;
25945            first = false;
25946        }
25947        if remaining & Self::ALLOW_ENCODE_QUANTIZATION_DELTA_MAP.0 != 0 {
25948            if !first {
25949                f.write_str(" | ")?;
25950            }
25951            f.write_str("ALLOW_ENCODE_QUANTIZATION_DELTA_MAP")?;
25952            remaining &= !Self::ALLOW_ENCODE_QUANTIZATION_DELTA_MAP.0;
25953            first = false;
25954        }
25955        if remaining & Self::ALLOW_ENCODE_EMPHASIS_MAP.0 != 0 {
25956            if !first {
25957                f.write_str(" | ")?;
25958            }
25959            f.write_str("ALLOW_ENCODE_EMPHASIS_MAP")?;
25960            remaining &= !Self::ALLOW_ENCODE_EMPHASIS_MAP.0;
25961            first = false;
25962        }
25963        if remaining & Self::INLINE_SESSION_PARAMETERS.0 != 0 {
25964            if !first {
25965                f.write_str(" | ")?;
25966            }
25967            f.write_str("INLINE_SESSION_PARAMETERS")?;
25968            remaining &= !Self::INLINE_SESSION_PARAMETERS.0;
25969            first = false;
25970        }
25971        if remaining != 0u32 {
25972            if !first {
25973                f.write_str(" | ")?;
25974            }
25975            write!(f, "{:#x}", remaining)?;
25976        } else if first {
25977            f.write_str("(empty)")?;
25978        }
25979        Ok(())
25980    }
25981}
25982///[`VkVideoSessionParametersCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateFlagBitsKHR.html)
25983#[repr(transparent)]
25984#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
25985#[doc(alias = "VkVideoSessionParametersCreateFlagBitsKHR")]
25986pub struct VideoSessionParametersCreateFlagBitsKHR(u32);
25987impl VideoSessionParametersCreateFlagBitsKHR {
25988    #[inline]
25989    pub const fn empty() -> Self {
25990        Self(0u32)
25991    }
25992    #[inline]
25993    pub const fn from_raw(value: u32) -> Self {
25994        Self(value)
25995    }
25996    #[inline]
25997    pub const fn as_raw(self) -> u32 {
25998        self.0
25999    }
26000    #[inline]
26001    pub const fn is_empty(self) -> bool {
26002        self.0 == 0u32
26003    }
26004    #[inline]
26005    pub const fn contains(self, other: Self) -> bool {
26006        (self.0 & other.0) == other.0
26007    }
26008    ///Bit 0.
26009    pub const QUANTIZATION_MAP_COMPATIBLE: Self = Self(1u32);
26010}
26011impl core::ops::BitOr for VideoSessionParametersCreateFlagBitsKHR {
26012    type Output = Self;
26013    #[inline]
26014    fn bitor(self, rhs: Self) -> Self {
26015        Self(self.0 | rhs.0)
26016    }
26017}
26018impl core::ops::BitOrAssign for VideoSessionParametersCreateFlagBitsKHR {
26019    #[inline]
26020    fn bitor_assign(&mut self, rhs: Self) {
26021        self.0 |= rhs.0;
26022    }
26023}
26024impl core::ops::BitAnd for VideoSessionParametersCreateFlagBitsKHR {
26025    type Output = Self;
26026    #[inline]
26027    fn bitand(self, rhs: Self) -> Self {
26028        Self(self.0 & rhs.0)
26029    }
26030}
26031impl core::ops::BitAndAssign for VideoSessionParametersCreateFlagBitsKHR {
26032    #[inline]
26033    fn bitand_assign(&mut self, rhs: Self) {
26034        self.0 &= rhs.0;
26035    }
26036}
26037impl core::ops::BitXor for VideoSessionParametersCreateFlagBitsKHR {
26038    type Output = Self;
26039    #[inline]
26040    fn bitxor(self, rhs: Self) -> Self {
26041        Self(self.0 ^ rhs.0)
26042    }
26043}
26044impl core::ops::BitXorAssign for VideoSessionParametersCreateFlagBitsKHR {
26045    #[inline]
26046    fn bitxor_assign(&mut self, rhs: Self) {
26047        self.0 ^= rhs.0;
26048    }
26049}
26050impl core::ops::Not for VideoSessionParametersCreateFlagBitsKHR {
26051    type Output = Self;
26052    #[inline]
26053    fn not(self) -> Self {
26054        Self(!self.0)
26055    }
26056}
26057impl core::fmt::Debug for VideoSessionParametersCreateFlagBitsKHR {
26058    #[allow(unused_mut, unused_variables)]
26059    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26060        let mut first = true;
26061        let mut remaining = self.0;
26062        if remaining & Self::QUANTIZATION_MAP_COMPATIBLE.0 != 0 {
26063            if !first {
26064                f.write_str(" | ")?;
26065            }
26066            f.write_str("QUANTIZATION_MAP_COMPATIBLE")?;
26067            remaining &= !Self::QUANTIZATION_MAP_COMPATIBLE.0;
26068            first = false;
26069        }
26070        if remaining != 0u32 {
26071            if !first {
26072                f.write_str(" | ")?;
26073            }
26074            write!(f, "{:#x}", remaining)?;
26075        } else if first {
26076            f.write_str("(empty)")?;
26077        }
26078        Ok(())
26079    }
26080}
26081///[`VkWaylandSurfaceCreateFlagBitsKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkWaylandSurfaceCreateFlagBitsKHR.html)
26082#[repr(transparent)]
26083#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
26084#[doc(alias = "VkWaylandSurfaceCreateFlagBitsKHR")]
26085pub struct WaylandSurfaceCreateFlagBitsKHR(u32);
26086impl WaylandSurfaceCreateFlagBitsKHR {
26087    #[inline]
26088    pub const fn empty() -> Self {
26089        Self(0u32)
26090    }
26091    #[inline]
26092    pub const fn from_raw(value: u32) -> Self {
26093        Self(value)
26094    }
26095    #[inline]
26096    pub const fn as_raw(self) -> u32 {
26097        self.0
26098    }
26099    #[inline]
26100    pub const fn is_empty(self) -> bool {
26101        self.0 == 0u32
26102    }
26103    #[inline]
26104    pub const fn contains(self, other: Self) -> bool {
26105        (self.0 & other.0) == other.0
26106    }
26107}
26108impl core::ops::BitOr for WaylandSurfaceCreateFlagBitsKHR {
26109    type Output = Self;
26110    #[inline]
26111    fn bitor(self, rhs: Self) -> Self {
26112        Self(self.0 | rhs.0)
26113    }
26114}
26115impl core::ops::BitOrAssign for WaylandSurfaceCreateFlagBitsKHR {
26116    #[inline]
26117    fn bitor_assign(&mut self, rhs: Self) {
26118        self.0 |= rhs.0;
26119    }
26120}
26121impl core::ops::BitAnd for WaylandSurfaceCreateFlagBitsKHR {
26122    type Output = Self;
26123    #[inline]
26124    fn bitand(self, rhs: Self) -> Self {
26125        Self(self.0 & rhs.0)
26126    }
26127}
26128impl core::ops::BitAndAssign for WaylandSurfaceCreateFlagBitsKHR {
26129    #[inline]
26130    fn bitand_assign(&mut self, rhs: Self) {
26131        self.0 &= rhs.0;
26132    }
26133}
26134impl core::ops::BitXor for WaylandSurfaceCreateFlagBitsKHR {
26135    type Output = Self;
26136    #[inline]
26137    fn bitxor(self, rhs: Self) -> Self {
26138        Self(self.0 ^ rhs.0)
26139    }
26140}
26141impl core::ops::BitXorAssign for WaylandSurfaceCreateFlagBitsKHR {
26142    #[inline]
26143    fn bitxor_assign(&mut self, rhs: Self) {
26144        self.0 ^= rhs.0;
26145    }
26146}
26147impl core::ops::Not for WaylandSurfaceCreateFlagBitsKHR {
26148    type Output = Self;
26149    #[inline]
26150    fn not(self) -> Self {
26151        Self(!self.0)
26152    }
26153}
26154impl core::fmt::Debug for WaylandSurfaceCreateFlagBitsKHR {
26155    #[allow(unused_mut, unused_variables)]
26156    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
26157        let mut first = true;
26158        let mut remaining = self.0;
26159        if remaining != 0u32 {
26160            if !first {
26161                f.write_str(" | ")?;
26162            }
26163            write!(f, "{:#x}", remaining)?;
26164        } else if first {
26165            f.write_str("(empty)")?;
26166        }
26167        Ok(())
26168    }
26169}
vulkan_rust_sys/bitmasks.rs

vulkan_rust_sys/
bitmasks.rs
