1#![allow(non_camel_case_types, non_upper_case_globals)]
3#[repr(transparent)]
4#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5pub struct ImageLayout(pub i32);
6impl ImageLayout {
7 pub const fn from_raw(value: i32) -> Self {
8 Self(value)
9 }
10
11 pub const fn as_raw(self) -> i32 {
12 self.0
13 }
14
15 pub const fn empty() -> Self {
16 Self(0)
17 }
18
19 pub const UNDEFINED: Self = Self(0);
20 pub const GENERAL: Self = Self(1);
21 pub const COLOR_ATTACHMENT_OPTIMAL: Self = Self(2);
22 pub const DEPTH_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(3);
23 pub const DEPTH_STENCIL_READ_ONLY_OPTIMAL: Self = Self(4);
24 pub const SHADER_READ_ONLY_OPTIMAL: Self = Self(5);
25 pub const TRANSFER_SRC_OPTIMAL: Self = Self(6);
26 pub const TRANSFER_DST_OPTIMAL: Self = Self(7);
27 pub const PREINITIALIZED: Self = Self(8);
28 pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1000117000);
29 pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = Self(1000117001);
30 pub const DEPTH_ATTACHMENT_OPTIMAL: Self = Self(1000241000);
31 pub const DEPTH_READ_ONLY_OPTIMAL: Self = Self(1000241001);
32 pub const STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1000241002);
33 pub const STENCIL_READ_ONLY_OPTIMAL: Self = Self(1000241003);
34 pub const READ_ONLY_OPTIMAL: Self = Self(1000314000);
35 pub const ATTACHMENT_OPTIMAL: Self = Self(1000314001);
36 pub const RENDERING_LOCAL_READ: Self = Self(1000232000);
37 pub const PRESENT_SRC_KHR: Self = Self(1000001002);
38 pub const VIDEO_DECODE_DST_KHR: Self = Self(1000024000);
39 pub const VIDEO_DECODE_SRC_KHR: Self = Self(1000024001);
40 pub const VIDEO_DECODE_DPB_KHR: Self = Self(1000024002);
41 pub const SHARED_PRESENT_KHR: Self = Self(1000111000);
42 pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = Self(1000117000);
43 pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: Self = Self(1000117001);
44 pub const SHADING_RATE_OPTIMAL_NV: Self = Self(1000164003);
45 pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1000218000);
46 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1000164003);
47 pub const RENDERING_LOCAL_READ_KHR: Self = Self(1000232000);
48 pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = Self(1000241000);
49 pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = Self(1000241001);
50 pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = Self(1000241002);
51 pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = Self(1000241003);
52 pub const VIDEO_ENCODE_DST_KHR: Self = Self(1000299000);
53 pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1000299001);
54 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1000299002);
55 pub const READ_ONLY_OPTIMAL_KHR: Self = Self(1000314000);
56 pub const ATTACHMENT_OPTIMAL_KHR: Self = Self(1000314001);
57 pub const ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: Self = Self(1000339000);
58 pub const TENSOR_ALIASING_ARM: Self = Self(1000460000);
59 pub const VIDEO_ENCODE_QUANTIZATION_MAP_KHR: Self = Self(1000553000);
60 pub const ZERO_INITIALIZED_EXT: Self = Self(1000620000);
61}
62
63#[repr(transparent)]
64#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
65pub struct AttachmentLoadOp(pub i32);
66impl AttachmentLoadOp {
67 pub const fn from_raw(value: i32) -> Self {
68 Self(value)
69 }
70
71 pub const fn as_raw(self) -> i32 {
72 self.0
73 }
74
75 pub const fn empty() -> Self {
76 Self(0)
77 }
78
79 pub const LOAD: Self = Self(0);
80 pub const CLEAR: Self = Self(1);
81 pub const DONT_CARE: Self = Self(2);
82 pub const NONE: Self = Self(1000400000);
83 pub const NONE_EXT: Self = Self(1000400000);
84 pub const NONE_KHR: Self = Self(1000400000);
85}
86
87#[repr(transparent)]
88#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
89pub struct AttachmentStoreOp(pub i32);
90impl AttachmentStoreOp {
91 pub const fn from_raw(value: i32) -> Self {
92 Self(value)
93 }
94
95 pub const fn as_raw(self) -> i32 {
96 self.0
97 }
98
99 pub const fn empty() -> Self {
100 Self(0)
101 }
102
103 pub const STORE: Self = Self(0);
104 pub const DONT_CARE: Self = Self(1);
105 pub const NONE: Self = Self(1000301000);
106 pub const NONE_KHR: Self = Self(1000301000);
107 pub const NONE_QCOM: Self = Self(1000301000);
108 pub const NONE_EXT: Self = Self(1000301000);
109}
110
111#[repr(transparent)]
112#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
113pub struct ImageType(pub i32);
114impl ImageType {
115 pub const fn from_raw(value: i32) -> Self {
116 Self(value)
117 }
118
119 pub const fn as_raw(self) -> i32 {
120 self.0
121 }
122
123 pub const fn empty() -> Self {
124 Self(0)
125 }
126
127 pub const _1D: Self = Self(0);
128 pub const _2D: Self = Self(1);
129 pub const _3D: Self = Self(2);
130}
131
132#[repr(transparent)]
133#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
134pub struct ImageTiling(pub i32);
135impl ImageTiling {
136 pub const fn from_raw(value: i32) -> Self {
137 Self(value)
138 }
139
140 pub const fn as_raw(self) -> i32 {
141 self.0
142 }
143
144 pub const fn empty() -> Self {
145 Self(0)
146 }
147
148 pub const OPTIMAL: Self = Self(0);
149 pub const LINEAR: Self = Self(1);
150 pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1000158000);
151}
152
153#[repr(transparent)]
154#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
155pub struct ImageViewType(pub i32);
156impl ImageViewType {
157 pub const fn from_raw(value: i32) -> Self {
158 Self(value)
159 }
160
161 pub const fn as_raw(self) -> i32 {
162 self.0
163 }
164
165 pub const fn empty() -> Self {
166 Self(0)
167 }
168
169 pub const _1D: Self = Self(0);
170 pub const _2D: Self = Self(1);
171 pub const _3D: Self = Self(2);
172 pub const CUBE: Self = Self(3);
173 pub const _1D_ARRAY: Self = Self(4);
174 pub const _2D_ARRAY: Self = Self(5);
175 pub const CUBE_ARRAY: Self = Self(6);
176}
177
178#[repr(transparent)]
179#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
180pub struct CommandBufferLevel(pub i32);
181impl CommandBufferLevel {
182 pub const fn from_raw(value: i32) -> Self {
183 Self(value)
184 }
185
186 pub const fn as_raw(self) -> i32 {
187 self.0
188 }
189
190 pub const fn empty() -> Self {
191 Self(0)
192 }
193
194 pub const PRIMARY: Self = Self(0);
195 pub const SECONDARY: Self = Self(1);
196}
197
198#[repr(transparent)]
199#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
200pub struct ComponentSwizzle(pub i32);
201impl ComponentSwizzle {
202 pub const fn from_raw(value: i32) -> Self {
203 Self(value)
204 }
205
206 pub const fn as_raw(self) -> i32 {
207 self.0
208 }
209
210 pub const fn empty() -> Self {
211 Self(0)
212 }
213
214 pub const IDENTITY: Self = Self(0);
215 pub const ZERO: Self = Self(1);
216 pub const ONE: Self = Self(2);
217 pub const R: Self = Self(3);
218 pub const G: Self = Self(4);
219 pub const B: Self = Self(5);
220 pub const A: Self = Self(6);
221}
222
223#[repr(transparent)]
224#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
225pub struct DescriptorType(pub i32);
226impl DescriptorType {
227 pub const fn from_raw(value: i32) -> Self {
228 Self(value)
229 }
230
231 pub const fn as_raw(self) -> i32 {
232 self.0
233 }
234
235 pub const fn empty() -> Self {
236 Self(0)
237 }
238
239 pub const SAMPLER: Self = Self(0);
240 pub const COMBINED_IMAGE_SAMPLER: Self = Self(1);
241 pub const SAMPLED_IMAGE: Self = Self(2);
242 pub const STORAGE_IMAGE: Self = Self(3);
243 pub const UNIFORM_TEXEL_BUFFER: Self = Self(4);
244 pub const STORAGE_TEXEL_BUFFER: Self = Self(5);
245 pub const UNIFORM_BUFFER: Self = Self(6);
246 pub const STORAGE_BUFFER: Self = Self(7);
247 pub const UNIFORM_BUFFER_DYNAMIC: Self = Self(8);
248 pub const STORAGE_BUFFER_DYNAMIC: Self = Self(9);
249 pub const INPUT_ATTACHMENT: Self = Self(10);
250 pub const INLINE_UNIFORM_BLOCK: Self = Self(1000138000);
251 pub const INLINE_UNIFORM_BLOCK_EXT: Self = Self(1000138000);
252 pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1000150000);
253 pub const ACCELERATION_STRUCTURE_NV: Self = Self(1000165000);
254 pub const MUTABLE_VALVE: Self = Self(1000351000);
255 pub const SAMPLE_WEIGHT_IMAGE_QCOM: Self = Self(1000440000);
256 pub const BLOCK_MATCH_IMAGE_QCOM: Self = Self(1000440001);
257 pub const TENSOR_ARM: Self = Self(1000460000);
258 pub const MUTABLE_EXT: Self = Self(1000351000);
259 pub const PARTITIONED_ACCELERATION_STRUCTURE_NV: Self = Self(1000570000);
260}
261
262#[repr(transparent)]
263#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
264pub struct QueryType(pub i32);
265impl QueryType {
266 pub const fn from_raw(value: i32) -> Self {
267 Self(value)
268 }
269
270 pub const fn as_raw(self) -> i32 {
271 self.0
272 }
273
274 pub const fn empty() -> Self {
275 Self(0)
276 }
277
278 pub const OCCLUSION: Self = Self(0);
279 pub const PIPELINE_STATISTICS: Self = Self(1);
280 pub const TIMESTAMP: Self = Self(2);
281 pub const RESULT_STATUS_ONLY_KHR: Self = Self(1000023000);
282 pub const TRANSFORM_FEEDBACK_STREAM_EXT: Self = Self(1000028004);
283 pub const PERFORMANCE_QUERY_KHR: Self = Self(1000116000);
284 pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1000150000);
285 pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1000150001);
286 pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = Self(1000165000);
287 pub const TIME_ELAPSED_QCOM: Self = Self(1000173000);
288 pub const PERFORMANCE_QUERY_INTEL: Self = Self(1000210000);
289 pub const VIDEO_ENCODE_FEEDBACK_KHR: Self = Self(1000299000);
290 pub const MESH_PRIMITIVES_GENERATED_EXT: Self = Self(1000328000);
291 pub const PRIMITIVES_GENERATED_EXT: Self = Self(1000382000);
292 pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: Self = Self(1000386000);
293 pub const ACCELERATION_STRUCTURE_SIZE_KHR: Self = Self(1000386001);
294 pub const MICROMAP_SERIALIZATION_SIZE_EXT: Self = Self(1000396000);
295 pub const MICROMAP_COMPACTED_SIZE_EXT: Self = Self(1000396001);
296}
297
298#[repr(transparent)]
299#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
300pub struct BorderColor(pub i32);
301impl BorderColor {
302 pub const fn from_raw(value: i32) -> Self {
303 Self(value)
304 }
305
306 pub const fn as_raw(self) -> i32 {
307 self.0
308 }
309
310 pub const fn empty() -> Self {
311 Self(0)
312 }
313
314 pub const FLOAT_TRANSPARENT_BLACK: Self = Self(0);
315 pub const INT_TRANSPARENT_BLACK: Self = Self(1);
316 pub const FLOAT_OPAQUE_BLACK: Self = Self(2);
317 pub const INT_OPAQUE_BLACK: Self = Self(3);
318 pub const FLOAT_OPAQUE_WHITE: Self = Self(4);
319 pub const INT_OPAQUE_WHITE: Self = Self(5);
320 pub const FLOAT_CUSTOM_EXT: Self = Self(1000287003);
321 pub const INT_CUSTOM_EXT: Self = Self(1000287004);
322}
323
324#[repr(transparent)]
325#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
326pub struct PipelineBindPoint(pub i32);
327impl PipelineBindPoint {
328 pub const fn from_raw(value: i32) -> Self {
329 Self(value)
330 }
331
332 pub const fn as_raw(self) -> i32 {
333 self.0
334 }
335
336 pub const fn empty() -> Self {
337 Self(0)
338 }
339
340 pub const GRAPHICS: Self = Self(0);
341 pub const COMPUTE: Self = Self(1);
342 #[cfg(feature = "provisional")]
343 pub const EXECUTION_GRAPH_AMDX: Self = Self(1000134000);
344 pub const RAY_TRACING_KHR: Self = Self(1000165000);
345 pub const RAY_TRACING_NV: Self = Self(1000165000);
346 pub const SUBPASS_SHADING_HUAWEI: Self = Self(1000369003);
347 pub const DATA_GRAPH_ARM: Self = Self(1000507000);
348}
349
350#[repr(transparent)]
351#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
352pub struct PipelineCacheHeaderVersion(pub i32);
353impl PipelineCacheHeaderVersion {
354 pub const fn from_raw(value: i32) -> Self {
355 Self(value)
356 }
357
358 pub const fn as_raw(self) -> i32 {
359 self.0
360 }
361
362 pub const fn empty() -> Self {
363 Self(0)
364 }
365
366 pub const ONE: Self = Self(1);
367 pub const DATA_GRAPH_QCOM: Self = Self(1000629000);
368}
369
370#[repr(transparent)]
371#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
372pub struct PipelineCacheCreateFlagBits(pub u32);
373impl PipelineCacheCreateFlagBits {
374 pub const fn from_raw(value: u32) -> Self {
375 Self(value)
376 }
377
378 pub const fn as_raw(self) -> u32 {
379 self.0
380 }
381
382 pub const fn empty() -> Self {
383 Self(0)
384 }
385
386 pub const EXTERNALLY_SYNCHRONIZED_BIT: Self = Self(1);
387 pub const EXTERNALLY_SYNCHRONIZED_BIT_EXT: Self = Self(1);
388 pub const INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR: Self = Self(8);
389}
390
391impl std::ops::BitOr for PipelineCacheCreateFlagBits {
392 type Output = Self;
393 fn bitor(self, rhs: Self) -> Self {
394 Self(self.0 | rhs.0)
395 }
396}
397
398impl std::ops::BitAnd for PipelineCacheCreateFlagBits {
399 type Output = Self;
400 fn bitand(self, rhs: Self) -> Self {
401 Self(self.0 & rhs.0)
402 }
403}
404
405impl std::ops::BitXor for PipelineCacheCreateFlagBits {
406 type Output = Self;
407 fn bitxor(self, rhs: Self) -> Self {
408 Self(self.0 ^ rhs.0)
409 }
410}
411
412impl std::ops::Not for PipelineCacheCreateFlagBits {
413 type Output = Self;
414 fn not(self) -> Self {
415 Self(!self.0)
416 }
417}
418
419#[repr(transparent)]
420#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
421pub struct PrimitiveTopology(pub i32);
422impl PrimitiveTopology {
423 pub const fn from_raw(value: i32) -> Self {
424 Self(value)
425 }
426
427 pub const fn as_raw(self) -> i32 {
428 self.0
429 }
430
431 pub const fn empty() -> Self {
432 Self(0)
433 }
434
435 pub const POINT_LIST: Self = Self(0);
436 pub const LINE_LIST: Self = Self(1);
437 pub const LINE_STRIP: Self = Self(2);
438 pub const TRIANGLE_LIST: Self = Self(3);
439 pub const TRIANGLE_STRIP: Self = Self(4);
440 pub const TRIANGLE_FAN: Self = Self(5);
441 pub const LINE_LIST_WITH_ADJACENCY: Self = Self(6);
442 pub const LINE_STRIP_WITH_ADJACENCY: Self = Self(7);
443 pub const TRIANGLE_LIST_WITH_ADJACENCY: Self = Self(8);
444 pub const TRIANGLE_STRIP_WITH_ADJACENCY: Self = Self(9);
445 pub const PATCH_LIST: Self = Self(10);
446}
447
448#[repr(transparent)]
449#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
450pub struct SharingMode(pub i32);
451impl SharingMode {
452 pub const fn from_raw(value: i32) -> Self {
453 Self(value)
454 }
455
456 pub const fn as_raw(self) -> i32 {
457 self.0
458 }
459
460 pub const fn empty() -> Self {
461 Self(0)
462 }
463
464 pub const EXCLUSIVE: Self = Self(0);
465 pub const CONCURRENT: Self = Self(1);
466}
467
468#[repr(transparent)]
469#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
470pub struct IndexType(pub i32);
471impl IndexType {
472 pub const fn from_raw(value: i32) -> Self {
473 Self(value)
474 }
475
476 pub const fn as_raw(self) -> i32 {
477 self.0
478 }
479
480 pub const fn empty() -> Self {
481 Self(0)
482 }
483
484 pub const UINT16: Self = Self(0);
485 pub const UINT32: Self = Self(1);
486 pub const UINT8: Self = Self(1000265000);
487 pub const NONE_KHR: Self = Self(1000165000);
488 pub const NONE_NV: Self = Self(1000165000);
489 pub const UINT8_EXT: Self = Self(1000265000);
490 pub const UINT8_KHR: Self = Self(1000265000);
491}
492
493#[repr(transparent)]
494#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
495pub struct Filter(pub i32);
496impl Filter {
497 pub const fn from_raw(value: i32) -> Self {
498 Self(value)
499 }
500
501 pub const fn as_raw(self) -> i32 {
502 self.0
503 }
504
505 pub const fn empty() -> Self {
506 Self(0)
507 }
508
509 pub const NEAREST: Self = Self(0);
510 pub const LINEAR: Self = Self(1);
511 pub const CUBIC_IMG: Self = Self(1000015000);
512 pub const CUBIC_EXT: Self = Self(1000015000);
513}
514
515#[repr(transparent)]
516#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
517pub struct SamplerMipmapMode(pub i32);
518impl SamplerMipmapMode {
519 pub const fn from_raw(value: i32) -> Self {
520 Self(value)
521 }
522
523 pub const fn as_raw(self) -> i32 {
524 self.0
525 }
526
527 pub const fn empty() -> Self {
528 Self(0)
529 }
530
531 pub const NEAREST: Self = Self(0);
532 pub const LINEAR: Self = Self(1);
533}
534
535#[repr(transparent)]
536#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
537pub struct SamplerAddressMode(pub i32);
538impl SamplerAddressMode {
539 pub const fn from_raw(value: i32) -> Self {
540 Self(value)
541 }
542
543 pub const fn as_raw(self) -> i32 {
544 self.0
545 }
546
547 pub const fn empty() -> Self {
548 Self(0)
549 }
550
551 pub const REPEAT: Self = Self(0);
552 pub const MIRRORED_REPEAT: Self = Self(1);
553 pub const CLAMP_TO_EDGE: Self = Self(2);
554 pub const CLAMP_TO_BORDER: Self = Self(3);
555 pub const MIRROR_CLAMP_TO_EDGE: Self = Self(4);
556 pub const MIRROR_CLAMP_TO_EDGE_KHR: Self = Self(4);
557}
558
559#[repr(transparent)]
560#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
561pub struct CompareOp(pub i32);
562impl CompareOp {
563 pub const fn from_raw(value: i32) -> Self {
564 Self(value)
565 }
566
567 pub const fn as_raw(self) -> i32 {
568 self.0
569 }
570
571 pub const fn empty() -> Self {
572 Self(0)
573 }
574
575 pub const NEVER: Self = Self(0);
576 pub const LESS: Self = Self(1);
577 pub const EQUAL: Self = Self(2);
578 pub const LESS_OR_EQUAL: Self = Self(3);
579 pub const GREATER: Self = Self(4);
580 pub const NOT_EQUAL: Self = Self(5);
581 pub const GREATER_OR_EQUAL: Self = Self(6);
582 pub const ALWAYS: Self = Self(7);
583}
584
585#[repr(transparent)]
586#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
587pub struct PolygonMode(pub i32);
588impl PolygonMode {
589 pub const fn from_raw(value: i32) -> Self {
590 Self(value)
591 }
592
593 pub const fn as_raw(self) -> i32 {
594 self.0
595 }
596
597 pub const fn empty() -> Self {
598 Self(0)
599 }
600
601 pub const FILL: Self = Self(0);
602 pub const LINE: Self = Self(1);
603 pub const POINT: Self = Self(2);
604 pub const FILL_RECTANGLE_NV: Self = Self(1000153000);
605}
606
607#[repr(transparent)]
608#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
609pub struct FrontFace(pub i32);
610impl FrontFace {
611 pub const fn from_raw(value: i32) -> Self {
612 Self(value)
613 }
614
615 pub const fn as_raw(self) -> i32 {
616 self.0
617 }
618
619 pub const fn empty() -> Self {
620 Self(0)
621 }
622
623 pub const COUNTER_CLOCKWISE: Self = Self(0);
624 pub const CLOCKWISE: Self = Self(1);
625}
626
627#[repr(transparent)]
628#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
629pub struct BlendFactor(pub i32);
630impl BlendFactor {
631 pub const fn from_raw(value: i32) -> Self {
632 Self(value)
633 }
634
635 pub const fn as_raw(self) -> i32 {
636 self.0
637 }
638
639 pub const fn empty() -> Self {
640 Self(0)
641 }
642
643 pub const ZERO: Self = Self(0);
644 pub const ONE: Self = Self(1);
645 pub const SRC_COLOR: Self = Self(2);
646 pub const ONE_MINUS_SRC_COLOR: Self = Self(3);
647 pub const DST_COLOR: Self = Self(4);
648 pub const ONE_MINUS_DST_COLOR: Self = Self(5);
649 pub const SRC_ALPHA: Self = Self(6);
650 pub const ONE_MINUS_SRC_ALPHA: Self = Self(7);
651 pub const DST_ALPHA: Self = Self(8);
652 pub const ONE_MINUS_DST_ALPHA: Self = Self(9);
653 pub const CONSTANT_COLOR: Self = Self(10);
654 pub const ONE_MINUS_CONSTANT_COLOR: Self = Self(11);
655 pub const CONSTANT_ALPHA: Self = Self(12);
656 pub const ONE_MINUS_CONSTANT_ALPHA: Self = Self(13);
657 pub const SRC_ALPHA_SATURATE: Self = Self(14);
658 pub const SRC1_COLOR: Self = Self(15);
659 pub const ONE_MINUS_SRC1_COLOR: Self = Self(16);
660 pub const SRC1_ALPHA: Self = Self(17);
661 pub const ONE_MINUS_SRC1_ALPHA: Self = Self(18);
662}
663
664#[repr(transparent)]
665#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
666pub struct BlendOp(pub i32);
667impl BlendOp {
668 pub const fn from_raw(value: i32) -> Self {
669 Self(value)
670 }
671
672 pub const fn as_raw(self) -> i32 {
673 self.0
674 }
675
676 pub const fn empty() -> Self {
677 Self(0)
678 }
679
680 pub const ADD: Self = Self(0);
681 pub const SUBTRACT: Self = Self(1);
682 pub const REVERSE_SUBTRACT: Self = Self(2);
683 pub const MIN: Self = Self(3);
684 pub const MAX: Self = Self(4);
685 pub const ZERO_EXT: Self = Self(1000148000);
686 pub const SRC_EXT: Self = Self(1000148001);
687 pub const DST_EXT: Self = Self(1000148002);
688 pub const SRC_OVER_EXT: Self = Self(1000148003);
689 pub const DST_OVER_EXT: Self = Self(1000148004);
690 pub const SRC_IN_EXT: Self = Self(1000148005);
691 pub const DST_IN_EXT: Self = Self(1000148006);
692 pub const SRC_OUT_EXT: Self = Self(1000148007);
693 pub const DST_OUT_EXT: Self = Self(1000148008);
694 pub const SRC_ATOP_EXT: Self = Self(1000148009);
695 pub const DST_ATOP_EXT: Self = Self(1000148010);
696 pub const XOR_EXT: Self = Self(1000148011);
697 pub const MULTIPLY_EXT: Self = Self(1000148012);
698 pub const SCREEN_EXT: Self = Self(1000148013);
699 pub const OVERLAY_EXT: Self = Self(1000148014);
700 pub const DARKEN_EXT: Self = Self(1000148015);
701 pub const LIGHTEN_EXT: Self = Self(1000148016);
702 pub const COLORDODGE_EXT: Self = Self(1000148017);
703 pub const COLORBURN_EXT: Self = Self(1000148018);
704 pub const HARDLIGHT_EXT: Self = Self(1000148019);
705 pub const SOFTLIGHT_EXT: Self = Self(1000148020);
706 pub const DIFFERENCE_EXT: Self = Self(1000148021);
707 pub const EXCLUSION_EXT: Self = Self(1000148022);
708 pub const INVERT_EXT: Self = Self(1000148023);
709 pub const INVERT_RGB_EXT: Self = Self(1000148024);
710 pub const LINEARDODGE_EXT: Self = Self(1000148025);
711 pub const LINEARBURN_EXT: Self = Self(1000148026);
712 pub const VIVIDLIGHT_EXT: Self = Self(1000148027);
713 pub const LINEARLIGHT_EXT: Self = Self(1000148028);
714 pub const PINLIGHT_EXT: Self = Self(1000148029);
715 pub const HARDMIX_EXT: Self = Self(1000148030);
716 pub const HSL_HUE_EXT: Self = Self(1000148031);
717 pub const HSL_SATURATION_EXT: Self = Self(1000148032);
718 pub const HSL_COLOR_EXT: Self = Self(1000148033);
719 pub const HSL_LUMINOSITY_EXT: Self = Self(1000148034);
720 pub const PLUS_EXT: Self = Self(1000148035);
721 pub const PLUS_CLAMPED_EXT: Self = Self(1000148036);
722 pub const PLUS_CLAMPED_ALPHA_EXT: Self = Self(1000148037);
723 pub const PLUS_DARKER_EXT: Self = Self(1000148038);
724 pub const MINUS_EXT: Self = Self(1000148039);
725 pub const MINUS_CLAMPED_EXT: Self = Self(1000148040);
726 pub const CONTRAST_EXT: Self = Self(1000148041);
727 pub const INVERT_OVG_EXT: Self = Self(1000148042);
728 pub const RED_EXT: Self = Self(1000148043);
729 pub const GREEN_EXT: Self = Self(1000148044);
730 pub const BLUE_EXT: Self = Self(1000148045);
731}
732
733#[repr(transparent)]
734#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
735pub struct StencilOp(pub i32);
736impl StencilOp {
737 pub const fn from_raw(value: i32) -> Self {
738 Self(value)
739 }
740
741 pub const fn as_raw(self) -> i32 {
742 self.0
743 }
744
745 pub const fn empty() -> Self {
746 Self(0)
747 }
748
749 pub const KEEP: Self = Self(0);
750 pub const ZERO: Self = Self(1);
751 pub const REPLACE: Self = Self(2);
752 pub const INCREMENT_AND_CLAMP: Self = Self(3);
753 pub const DECREMENT_AND_CLAMP: Self = Self(4);
754 pub const INVERT: Self = Self(5);
755 pub const INCREMENT_AND_WRAP: Self = Self(6);
756 pub const DECREMENT_AND_WRAP: Self = Self(7);
757}
758
759#[repr(transparent)]
760#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
761pub struct LogicOp(pub i32);
762impl LogicOp {
763 pub const fn from_raw(value: i32) -> Self {
764 Self(value)
765 }
766
767 pub const fn as_raw(self) -> i32 {
768 self.0
769 }
770
771 pub const fn empty() -> Self {
772 Self(0)
773 }
774
775 pub const CLEAR: Self = Self(0);
776 pub const AND: Self = Self(1);
777 pub const AND_REVERSE: Self = Self(2);
778 pub const COPY: Self = Self(3);
779 pub const AND_INVERTED: Self = Self(4);
780 pub const NO_OP: Self = Self(5);
781 pub const XOR: Self = Self(6);
782 pub const OR: Self = Self(7);
783 pub const NOR: Self = Self(8);
784 pub const EQUIVALENT: Self = Self(9);
785 pub const INVERT: Self = Self(10);
786 pub const OR_REVERSE: Self = Self(11);
787 pub const COPY_INVERTED: Self = Self(12);
788 pub const OR_INVERTED: Self = Self(13);
789 pub const NAND: Self = Self(14);
790 pub const SET: Self = Self(15);
791}
792
793#[repr(transparent)]
794#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
795pub struct InternalAllocationType(pub i32);
796impl InternalAllocationType {
797 pub const fn from_raw(value: i32) -> Self {
798 Self(value)
799 }
800
801 pub const fn as_raw(self) -> i32 {
802 self.0
803 }
804
805 pub const fn empty() -> Self {
806 Self(0)
807 }
808
809 pub const EXECUTABLE: Self = Self(0);
810}
811
812#[repr(transparent)]
813#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
814pub struct SystemAllocationScope(pub i32);
815impl SystemAllocationScope {
816 pub const fn from_raw(value: i32) -> Self {
817 Self(value)
818 }
819
820 pub const fn as_raw(self) -> i32 {
821 self.0
822 }
823
824 pub const fn empty() -> Self {
825 Self(0)
826 }
827
828 pub const COMMAND: Self = Self(0);
829 pub const OBJECT: Self = Self(1);
830 pub const CACHE: Self = Self(2);
831 pub const DEVICE: Self = Self(3);
832 pub const INSTANCE: Self = Self(4);
833}
834
835#[repr(transparent)]
836#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
837pub struct PhysicalDeviceType(pub i32);
838impl PhysicalDeviceType {
839 pub const fn from_raw(value: i32) -> Self {
840 Self(value)
841 }
842
843 pub const fn as_raw(self) -> i32 {
844 self.0
845 }
846
847 pub const fn empty() -> Self {
848 Self(0)
849 }
850
851 pub const OTHER: Self = Self(0);
852 pub const INTEGRATED_GPU: Self = Self(1);
853 pub const DISCRETE_GPU: Self = Self(2);
854 pub const VIRTUAL_GPU: Self = Self(3);
855 pub const CPU: Self = Self(4);
856}
857
858#[repr(transparent)]
859#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
860pub struct VertexInputRate(pub i32);
861impl VertexInputRate {
862 pub const fn from_raw(value: i32) -> Self {
863 Self(value)
864 }
865
866 pub const fn as_raw(self) -> i32 {
867 self.0
868 }
869
870 pub const fn empty() -> Self {
871 Self(0)
872 }
873
874 pub const VERTEX: Self = Self(0);
875 pub const INSTANCE: Self = Self(1);
876}
877
878#[repr(transparent)]
879#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
880pub struct Format(pub i32);
881impl Format {
882 pub const fn from_raw(value: i32) -> Self {
883 Self(value)
884 }
885
886 pub const fn as_raw(self) -> i32 {
887 self.0
888 }
889
890 pub const fn empty() -> Self {
891 Self(0)
892 }
893
894 pub const UNDEFINED: Self = Self(0);
895 pub const R4G4_UNORM_PACK8: Self = Self(1);
896 pub const R4G4B4A4_UNORM_PACK16: Self = Self(2);
897 pub const B4G4R4A4_UNORM_PACK16: Self = Self(3);
898 pub const R5G6B5_UNORM_PACK16: Self = Self(4);
899 pub const B5G6R5_UNORM_PACK16: Self = Self(5);
900 pub const R5G5B5A1_UNORM_PACK16: Self = Self(6);
901 pub const B5G5R5A1_UNORM_PACK16: Self = Self(7);
902 pub const A1R5G5B5_UNORM_PACK16: Self = Self(8);
903 pub const R8_UNORM: Self = Self(9);
904 pub const R8_SNORM: Self = Self(10);
905 pub const R8_USCALED: Self = Self(11);
906 pub const R8_SSCALED: Self = Self(12);
907 pub const R8_UINT: Self = Self(13);
908 pub const R8_SINT: Self = Self(14);
909 pub const R8_SRGB: Self = Self(15);
910 pub const R8G8_UNORM: Self = Self(16);
911 pub const R8G8_SNORM: Self = Self(17);
912 pub const R8G8_USCALED: Self = Self(18);
913 pub const R8G8_SSCALED: Self = Self(19);
914 pub const R8G8_UINT: Self = Self(20);
915 pub const R8G8_SINT: Self = Self(21);
916 pub const R8G8_SRGB: Self = Self(22);
917 pub const R8G8B8_UNORM: Self = Self(23);
918 pub const R8G8B8_SNORM: Self = Self(24);
919 pub const R8G8B8_USCALED: Self = Self(25);
920 pub const R8G8B8_SSCALED: Self = Self(26);
921 pub const R8G8B8_UINT: Self = Self(27);
922 pub const R8G8B8_SINT: Self = Self(28);
923 pub const R8G8B8_SRGB: Self = Self(29);
924 pub const B8G8R8_UNORM: Self = Self(30);
925 pub const B8G8R8_SNORM: Self = Self(31);
926 pub const B8G8R8_USCALED: Self = Self(32);
927 pub const B8G8R8_SSCALED: Self = Self(33);
928 pub const B8G8R8_UINT: Self = Self(34);
929 pub const B8G8R8_SINT: Self = Self(35);
930 pub const B8G8R8_SRGB: Self = Self(36);
931 pub const R8G8B8A8_UNORM: Self = Self(37);
932 pub const R8G8B8A8_SNORM: Self = Self(38);
933 pub const R8G8B8A8_USCALED: Self = Self(39);
934 pub const R8G8B8A8_SSCALED: Self = Self(40);
935 pub const R8G8B8A8_UINT: Self = Self(41);
936 pub const R8G8B8A8_SINT: Self = Self(42);
937 pub const R8G8B8A8_SRGB: Self = Self(43);
938 pub const B8G8R8A8_UNORM: Self = Self(44);
939 pub const B8G8R8A8_SNORM: Self = Self(45);
940 pub const B8G8R8A8_USCALED: Self = Self(46);
941 pub const B8G8R8A8_SSCALED: Self = Self(47);
942 pub const B8G8R8A8_UINT: Self = Self(48);
943 pub const B8G8R8A8_SINT: Self = Self(49);
944 pub const B8G8R8A8_SRGB: Self = Self(50);
945 pub const A8B8G8R8_UNORM_PACK32: Self = Self(51);
946 pub const A8B8G8R8_SNORM_PACK32: Self = Self(52);
947 pub const A8B8G8R8_USCALED_PACK32: Self = Self(53);
948 pub const A8B8G8R8_SSCALED_PACK32: Self = Self(54);
949 pub const A8B8G8R8_UINT_PACK32: Self = Self(55);
950 pub const A8B8G8R8_SINT_PACK32: Self = Self(56);
951 pub const A8B8G8R8_SRGB_PACK32: Self = Self(57);
952 pub const A2R10G10B10_UNORM_PACK32: Self = Self(58);
953 pub const A2R10G10B10_SNORM_PACK32: Self = Self(59);
954 pub const A2R10G10B10_USCALED_PACK32: Self = Self(60);
955 pub const A2R10G10B10_SSCALED_PACK32: Self = Self(61);
956 pub const A2R10G10B10_UINT_PACK32: Self = Self(62);
957 pub const A2R10G10B10_SINT_PACK32: Self = Self(63);
958 pub const A2B10G10R10_UNORM_PACK32: Self = Self(64);
959 pub const A2B10G10R10_SNORM_PACK32: Self = Self(65);
960 pub const A2B10G10R10_USCALED_PACK32: Self = Self(66);
961 pub const A2B10G10R10_SSCALED_PACK32: Self = Self(67);
962 pub const A2B10G10R10_UINT_PACK32: Self = Self(68);
963 pub const A2B10G10R10_SINT_PACK32: Self = Self(69);
964 pub const R16_UNORM: Self = Self(70);
965 pub const R16_SNORM: Self = Self(71);
966 pub const R16_USCALED: Self = Self(72);
967 pub const R16_SSCALED: Self = Self(73);
968 pub const R16_UINT: Self = Self(74);
969 pub const R16_SINT: Self = Self(75);
970 pub const R16_SFLOAT: Self = Self(76);
971 pub const R16G16_UNORM: Self = Self(77);
972 pub const R16G16_SNORM: Self = Self(78);
973 pub const R16G16_USCALED: Self = Self(79);
974 pub const R16G16_SSCALED: Self = Self(80);
975 pub const R16G16_UINT: Self = Self(81);
976 pub const R16G16_SINT: Self = Self(82);
977 pub const R16G16_SFLOAT: Self = Self(83);
978 pub const R16G16B16_UNORM: Self = Self(84);
979 pub const R16G16B16_SNORM: Self = Self(85);
980 pub const R16G16B16_USCALED: Self = Self(86);
981 pub const R16G16B16_SSCALED: Self = Self(87);
982 pub const R16G16B16_UINT: Self = Self(88);
983 pub const R16G16B16_SINT: Self = Self(89);
984 pub const R16G16B16_SFLOAT: Self = Self(90);
985 pub const R16G16B16A16_UNORM: Self = Self(91);
986 pub const R16G16B16A16_SNORM: Self = Self(92);
987 pub const R16G16B16A16_USCALED: Self = Self(93);
988 pub const R16G16B16A16_SSCALED: Self = Self(94);
989 pub const R16G16B16A16_UINT: Self = Self(95);
990 pub const R16G16B16A16_SINT: Self = Self(96);
991 pub const R16G16B16A16_SFLOAT: Self = Self(97);
992 pub const R32_UINT: Self = Self(98);
993 pub const R32_SINT: Self = Self(99);
994 pub const R32_SFLOAT: Self = Self(100);
995 pub const R32G32_UINT: Self = Self(101);
996 pub const R32G32_SINT: Self = Self(102);
997 pub const R32G32_SFLOAT: Self = Self(103);
998 pub const R32G32B32_UINT: Self = Self(104);
999 pub const R32G32B32_SINT: Self = Self(105);
1000 pub const R32G32B32_SFLOAT: Self = Self(106);
1001 pub const R32G32B32A32_UINT: Self = Self(107);
1002 pub const R32G32B32A32_SINT: Self = Self(108);
1003 pub const R32G32B32A32_SFLOAT: Self = Self(109);
1004 pub const R64_UINT: Self = Self(110);
1005 pub const R64_SINT: Self = Self(111);
1006 pub const R64_SFLOAT: Self = Self(112);
1007 pub const R64G64_UINT: Self = Self(113);
1008 pub const R64G64_SINT: Self = Self(114);
1009 pub const R64G64_SFLOAT: Self = Self(115);
1010 pub const R64G64B64_UINT: Self = Self(116);
1011 pub const R64G64B64_SINT: Self = Self(117);
1012 pub const R64G64B64_SFLOAT: Self = Self(118);
1013 pub const R64G64B64A64_UINT: Self = Self(119);
1014 pub const R64G64B64A64_SINT: Self = Self(120);
1015 pub const R64G64B64A64_SFLOAT: Self = Self(121);
1016 pub const B10G11R11_UFLOAT_PACK32: Self = Self(122);
1017 pub const E5B9G9R9_UFLOAT_PACK32: Self = Self(123);
1018 pub const D16_UNORM: Self = Self(124);
1019 pub const X8_D24_UNORM_PACK32: Self = Self(125);
1020 pub const D32_SFLOAT: Self = Self(126);
1021 pub const S8_UINT: Self = Self(127);
1022 pub const D16_UNORM_S8_UINT: Self = Self(128);
1023 pub const D24_UNORM_S8_UINT: Self = Self(129);
1024 pub const D32_SFLOAT_S8_UINT: Self = Self(130);
1025 pub const BC1_RGB_UNORM_BLOCK: Self = Self(131);
1026 pub const BC1_RGB_SRGB_BLOCK: Self = Self(132);
1027 pub const BC1_RGBA_UNORM_BLOCK: Self = Self(133);
1028 pub const BC1_RGBA_SRGB_BLOCK: Self = Self(134);
1029 pub const BC2_UNORM_BLOCK: Self = Self(135);
1030 pub const BC2_SRGB_BLOCK: Self = Self(136);
1031 pub const BC3_UNORM_BLOCK: Self = Self(137);
1032 pub const BC3_SRGB_BLOCK: Self = Self(138);
1033 pub const BC4_UNORM_BLOCK: Self = Self(139);
1034 pub const BC4_SNORM_BLOCK: Self = Self(140);
1035 pub const BC5_UNORM_BLOCK: Self = Self(141);
1036 pub const BC5_SNORM_BLOCK: Self = Self(142);
1037 pub const BC6H_UFLOAT_BLOCK: Self = Self(143);
1038 pub const BC6H_SFLOAT_BLOCK: Self = Self(144);
1039 pub const BC7_UNORM_BLOCK: Self = Self(145);
1040 pub const BC7_SRGB_BLOCK: Self = Self(146);
1041 pub const ETC2_R8G8B8_UNORM_BLOCK: Self = Self(147);
1042 pub const ETC2_R8G8B8_SRGB_BLOCK: Self = Self(148);
1043 pub const ETC2_R8G8B8A1_UNORM_BLOCK: Self = Self(149);
1044 pub const ETC2_R8G8B8A1_SRGB_BLOCK: Self = Self(150);
1045 pub const ETC2_R8G8B8A8_UNORM_BLOCK: Self = Self(151);
1046 pub const ETC2_R8G8B8A8_SRGB_BLOCK: Self = Self(152);
1047 pub const EAC_R11_UNORM_BLOCK: Self = Self(153);
1048 pub const EAC_R11_SNORM_BLOCK: Self = Self(154);
1049 pub const EAC_R11G11_UNORM_BLOCK: Self = Self(155);
1050 pub const EAC_R11G11_SNORM_BLOCK: Self = Self(156);
1051 pub const ASTC_4x4_UNORM_BLOCK: Self = Self(157);
1052 pub const ASTC_4x4_SRGB_BLOCK: Self = Self(158);
1053 pub const ASTC_5x4_UNORM_BLOCK: Self = Self(159);
1054 pub const ASTC_5x4_SRGB_BLOCK: Self = Self(160);
1055 pub const ASTC_5x5_UNORM_BLOCK: Self = Self(161);
1056 pub const ASTC_5x5_SRGB_BLOCK: Self = Self(162);
1057 pub const ASTC_6x5_UNORM_BLOCK: Self = Self(163);
1058 pub const ASTC_6x5_SRGB_BLOCK: Self = Self(164);
1059 pub const ASTC_6x6_UNORM_BLOCK: Self = Self(165);
1060 pub const ASTC_6x6_SRGB_BLOCK: Self = Self(166);
1061 pub const ASTC_8x5_UNORM_BLOCK: Self = Self(167);
1062 pub const ASTC_8x5_SRGB_BLOCK: Self = Self(168);
1063 pub const ASTC_8x6_UNORM_BLOCK: Self = Self(169);
1064 pub const ASTC_8x6_SRGB_BLOCK: Self = Self(170);
1065 pub const ASTC_8x8_UNORM_BLOCK: Self = Self(171);
1066 pub const ASTC_8x8_SRGB_BLOCK: Self = Self(172);
1067 pub const ASTC_10x5_UNORM_BLOCK: Self = Self(173);
1068 pub const ASTC_10x5_SRGB_BLOCK: Self = Self(174);
1069 pub const ASTC_10x6_UNORM_BLOCK: Self = Self(175);
1070 pub const ASTC_10x6_SRGB_BLOCK: Self = Self(176);
1071 pub const ASTC_10x8_UNORM_BLOCK: Self = Self(177);
1072 pub const ASTC_10x8_SRGB_BLOCK: Self = Self(178);
1073 pub const ASTC_10x10_UNORM_BLOCK: Self = Self(179);
1074 pub const ASTC_10x10_SRGB_BLOCK: Self = Self(180);
1075 pub const ASTC_12x10_UNORM_BLOCK: Self = Self(181);
1076 pub const ASTC_12x10_SRGB_BLOCK: Self = Self(182);
1077 pub const ASTC_12x12_UNORM_BLOCK: Self = Self(183);
1078 pub const ASTC_12x12_SRGB_BLOCK: Self = Self(184);
1079 pub const G8B8G8R8_422_UNORM: Self = Self(1000156000);
1080 pub const B8G8R8G8_422_UNORM: Self = Self(1000156001);
1081 pub const G8_B8_R8_3PLANE_420_UNORM: Self = Self(1000156002);
1082 pub const G8_B8R8_2PLANE_420_UNORM: Self = Self(1000156003);
1083 pub const G8_B8_R8_3PLANE_422_UNORM: Self = Self(1000156004);
1084 pub const G8_B8R8_2PLANE_422_UNORM: Self = Self(1000156005);
1085 pub const G8_B8_R8_3PLANE_444_UNORM: Self = Self(1000156006);
1086 pub const R10X6_UNORM_PACK16: Self = Self(1000156007);
1087 pub const R10X6G10X6_UNORM_2PACK16: Self = Self(1000156008);
1088 pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Self(1000156009);
1089 pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Self(1000156010);
1090 pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Self(1000156011);
1091 pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Self(1000156012);
1092 pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Self(1000156013);
1093 pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Self(1000156014);
1094 pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Self(1000156015);
1095 pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Self(1000156016);
1096 pub const R12X4_UNORM_PACK16: Self = Self(1000156017);
1097 pub const R12X4G12X4_UNORM_2PACK16: Self = Self(1000156018);
1098 pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Self(1000156019);
1099 pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Self(1000156020);
1100 pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Self(1000156021);
1101 pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Self(1000156022);
1102 pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Self(1000156023);
1103 pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Self(1000156024);
1104 pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Self(1000156025);
1105 pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Self(1000156026);
1106 pub const G16B16G16R16_422_UNORM: Self = Self(1000156027);
1107 pub const B16G16R16G16_422_UNORM: Self = Self(1000156028);
1108 pub const G16_B16_R16_3PLANE_420_UNORM: Self = Self(1000156029);
1109 pub const G16_B16R16_2PLANE_420_UNORM: Self = Self(1000156030);
1110 pub const G16_B16_R16_3PLANE_422_UNORM: Self = Self(1000156031);
1111 pub const G16_B16R16_2PLANE_422_UNORM: Self = Self(1000156032);
1112 pub const G16_B16_R16_3PLANE_444_UNORM: Self = Self(1000156033);
1113 pub const G8_B8R8_2PLANE_444_UNORM: Self = Self(1000330000);
1114 pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: Self = Self(1000330001);
1115 pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: Self = Self(1000330002);
1116 pub const G16_B16R16_2PLANE_444_UNORM: Self = Self(1000330003);
1117 pub const A4R4G4B4_UNORM_PACK16: Self = Self(1000340000);
1118 pub const A4B4G4R4_UNORM_PACK16: Self = Self(1000340001);
1119 pub const ASTC_4x4_SFLOAT_BLOCK: Self = Self(1000066000);
1120 pub const ASTC_5x4_SFLOAT_BLOCK: Self = Self(1000066001);
1121 pub const ASTC_5x5_SFLOAT_BLOCK: Self = Self(1000066002);
1122 pub const ASTC_6x5_SFLOAT_BLOCK: Self = Self(1000066003);
1123 pub const ASTC_6x6_SFLOAT_BLOCK: Self = Self(1000066004);
1124 pub const ASTC_8x5_SFLOAT_BLOCK: Self = Self(1000066005);
1125 pub const ASTC_8x6_SFLOAT_BLOCK: Self = Self(1000066006);
1126 pub const ASTC_8x8_SFLOAT_BLOCK: Self = Self(1000066007);
1127 pub const ASTC_10x5_SFLOAT_BLOCK: Self = Self(1000066008);
1128 pub const ASTC_10x6_SFLOAT_BLOCK: Self = Self(1000066009);
1129 pub const ASTC_10x8_SFLOAT_BLOCK: Self = Self(1000066010);
1130 pub const ASTC_10x10_SFLOAT_BLOCK: Self = Self(1000066011);
1131 pub const ASTC_12x10_SFLOAT_BLOCK: Self = Self(1000066012);
1132 pub const ASTC_12x12_SFLOAT_BLOCK: Self = Self(1000066013);
1133 pub const A1B5G5R5_UNORM_PACK16: Self = Self(1000470000);
1134 pub const A8_UNORM: Self = Self(1000470001);
1135 pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Self(1000054000);
1136 pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Self(1000054001);
1137 pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Self(1000054002);
1138 pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Self(1000054003);
1139 pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Self(1000054004);
1140 pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Self(1000054005);
1141 pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Self(1000054006);
1142 pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Self(1000054007);
1143 pub const ASTC_4x4_SFLOAT_BLOCK_EXT: Self = Self(1000066000);
1144 pub const ASTC_5x4_SFLOAT_BLOCK_EXT: Self = Self(1000066001);
1145 pub const ASTC_5x5_SFLOAT_BLOCK_EXT: Self = Self(1000066002);
1146 pub const ASTC_6x5_SFLOAT_BLOCK_EXT: Self = Self(1000066003);
1147 pub const ASTC_6x6_SFLOAT_BLOCK_EXT: Self = Self(1000066004);
1148 pub const ASTC_8x5_SFLOAT_BLOCK_EXT: Self = Self(1000066005);
1149 pub const ASTC_8x6_SFLOAT_BLOCK_EXT: Self = Self(1000066006);
1150 pub const ASTC_8x8_SFLOAT_BLOCK_EXT: Self = Self(1000066007);
1151 pub const ASTC_10x5_SFLOAT_BLOCK_EXT: Self = Self(1000066008);
1152 pub const ASTC_10x6_SFLOAT_BLOCK_EXT: Self = Self(1000066009);
1153 pub const ASTC_10x8_SFLOAT_BLOCK_EXT: Self = Self(1000066010);
1154 pub const ASTC_10x10_SFLOAT_BLOCK_EXT: Self = Self(1000066011);
1155 pub const ASTC_12x10_SFLOAT_BLOCK_EXT: Self = Self(1000066012);
1156 pub const ASTC_12x12_SFLOAT_BLOCK_EXT: Self = Self(1000066013);
1157 pub const G8B8G8R8_422_UNORM_KHR: Self = Self(1000156000);
1158 pub const B8G8R8G8_422_UNORM_KHR: Self = Self(1000156001);
1159 pub const G8_B8_R8_3PLANE_420_UNORM_KHR: Self = Self(1000156002);
1160 pub const G8_B8R8_2PLANE_420_UNORM_KHR: Self = Self(1000156003);
1161 pub const G8_B8_R8_3PLANE_422_UNORM_KHR: Self = Self(1000156004);
1162 pub const G8_B8R8_2PLANE_422_UNORM_KHR: Self = Self(1000156005);
1163 pub const G8_B8_R8_3PLANE_444_UNORM_KHR: Self = Self(1000156006);
1164 pub const R10X6_UNORM_PACK16_KHR: Self = Self(1000156007);
1165 pub const R10X6G10X6_UNORM_2PACK16_KHR: Self = Self(1000156008);
1166 pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: Self = Self(1000156009);
1167 pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: Self = Self(1000156010);
1168 pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: Self = Self(1000156011);
1169 pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: Self = Self(1000156012);
1170 pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: Self = Self(1000156013);
1171 pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: Self = Self(1000156014);
1172 pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: Self = Self(1000156015);
1173 pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: Self = Self(1000156016);
1174 pub const R12X4_UNORM_PACK16_KHR: Self = Self(1000156017);
1175 pub const R12X4G12X4_UNORM_2PACK16_KHR: Self = Self(1000156018);
1176 pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: Self = Self(1000156019);
1177 pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: Self = Self(1000156020);
1178 pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: Self = Self(1000156021);
1179 pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: Self = Self(1000156022);
1180 pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: Self = Self(1000156023);
1181 pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: Self = Self(1000156024);
1182 pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: Self = Self(1000156025);
1183 pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: Self = Self(1000156026);
1184 pub const G16B16G16R16_422_UNORM_KHR: Self = Self(1000156027);
1185 pub const B16G16R16G16_422_UNORM_KHR: Self = Self(1000156028);
1186 pub const G16_B16_R16_3PLANE_420_UNORM_KHR: Self = Self(1000156029);
1187 pub const G16_B16R16_2PLANE_420_UNORM_KHR: Self = Self(1000156030);
1188 pub const G16_B16_R16_3PLANE_422_UNORM_KHR: Self = Self(1000156031);
1189 pub const G16_B16R16_2PLANE_422_UNORM_KHR: Self = Self(1000156032);
1190 pub const G16_B16_R16_3PLANE_444_UNORM_KHR: Self = Self(1000156033);
1191 pub const ASTC_3x3x3_UNORM_BLOCK_EXT: Self = Self(1000288000);
1192 pub const ASTC_3x3x3_SRGB_BLOCK_EXT: Self = Self(1000288001);
1193 pub const ASTC_3x3x3_SFLOAT_BLOCK_EXT: Self = Self(1000288002);
1194 pub const ASTC_4x3x3_UNORM_BLOCK_EXT: Self = Self(1000288003);
1195 pub const ASTC_4x3x3_SRGB_BLOCK_EXT: Self = Self(1000288004);
1196 pub const ASTC_4x3x3_SFLOAT_BLOCK_EXT: Self = Self(1000288005);
1197 pub const ASTC_4x4x3_UNORM_BLOCK_EXT: Self = Self(1000288006);
1198 pub const ASTC_4x4x3_SRGB_BLOCK_EXT: Self = Self(1000288007);
1199 pub const ASTC_4x4x3_SFLOAT_BLOCK_EXT: Self = Self(1000288008);
1200 pub const ASTC_4x4x4_UNORM_BLOCK_EXT: Self = Self(1000288009);
1201 pub const ASTC_4x4x4_SRGB_BLOCK_EXT: Self = Self(1000288010);
1202 pub const ASTC_4x4x4_SFLOAT_BLOCK_EXT: Self = Self(1000288011);
1203 pub const ASTC_5x4x4_UNORM_BLOCK_EXT: Self = Self(1000288012);
1204 pub const ASTC_5x4x4_SRGB_BLOCK_EXT: Self = Self(1000288013);
1205 pub const ASTC_5x4x4_SFLOAT_BLOCK_EXT: Self = Self(1000288014);
1206 pub const ASTC_5x5x4_UNORM_BLOCK_EXT: Self = Self(1000288015);
1207 pub const ASTC_5x5x4_SRGB_BLOCK_EXT: Self = Self(1000288016);
1208 pub const ASTC_5x5x4_SFLOAT_BLOCK_EXT: Self = Self(1000288017);
1209 pub const ASTC_5x5x5_UNORM_BLOCK_EXT: Self = Self(1000288018);
1210 pub const ASTC_5x5x5_SRGB_BLOCK_EXT: Self = Self(1000288019);
1211 pub const ASTC_5x5x5_SFLOAT_BLOCK_EXT: Self = Self(1000288020);
1212 pub const ASTC_6x5x5_UNORM_BLOCK_EXT: Self = Self(1000288021);
1213 pub const ASTC_6x5x5_SRGB_BLOCK_EXT: Self = Self(1000288022);
1214 pub const ASTC_6x5x5_SFLOAT_BLOCK_EXT: Self = Self(1000288023);
1215 pub const ASTC_6x6x5_UNORM_BLOCK_EXT: Self = Self(1000288024);
1216 pub const ASTC_6x6x5_SRGB_BLOCK_EXT: Self = Self(1000288025);
1217 pub const ASTC_6x6x5_SFLOAT_BLOCK_EXT: Self = Self(1000288026);
1218 pub const ASTC_6x6x6_UNORM_BLOCK_EXT: Self = Self(1000288027);
1219 pub const ASTC_6x6x6_SRGB_BLOCK_EXT: Self = Self(1000288028);
1220 pub const ASTC_6x6x6_SFLOAT_BLOCK_EXT: Self = Self(1000288029);
1221 pub const G8_B8R8_2PLANE_444_UNORM_EXT: Self = Self(1000330000);
1222 pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: Self = Self(1000330001);
1223 pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: Self = Self(1000330002);
1224 pub const G16_B16R16_2PLANE_444_UNORM_EXT: Self = Self(1000330003);
1225 pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self(1000340000);
1226 pub const A4B4G4R4_UNORM_PACK16_EXT: Self = Self(1000340001);
1227 pub const R8_BOOL_ARM: Self = Self(1000460000);
1228 pub const R16_SFLOAT_FPENCODING_BFLOAT16_ARM: Self = Self(1000460001);
1229 pub const R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM: Self = Self(1000460002);
1230 pub const R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM: Self = Self(1000460003);
1231 pub const R16G16_SFIXED5_NV: Self = Self(1000464000);
1232 pub const R16G16_S10_5_NV: Self = Self(1000464000);
1233 pub const A1B5G5R5_UNORM_PACK16_KHR: Self = Self(1000470000);
1234 pub const A8_UNORM_KHR: Self = Self(1000470001);
1235 pub const R10X6_UINT_PACK16_ARM: Self = Self(1000609000);
1236 pub const R10X6G10X6_UINT_2PACK16_ARM: Self = Self(1000609001);
1237 pub const R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM: Self = Self(1000609002);
1238 pub const R12X4_UINT_PACK16_ARM: Self = Self(1000609003);
1239 pub const R12X4G12X4_UINT_2PACK16_ARM: Self = Self(1000609004);
1240 pub const R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM: Self = Self(1000609005);
1241 pub const R14X2_UINT_PACK16_ARM: Self = Self(1000609006);
1242 pub const R14X2G14X2_UINT_2PACK16_ARM: Self = Self(1000609007);
1243 pub const R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM: Self = Self(1000609008);
1244 pub const R14X2_UNORM_PACK16_ARM: Self = Self(1000609009);
1245 pub const R14X2G14X2_UNORM_2PACK16_ARM: Self = Self(1000609010);
1246 pub const R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM: Self = Self(1000609011);
1247 pub const G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: Self = Self(1000609012);
1248 pub const G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: Self = Self(1000609013);
1249}
1250
1251#[repr(transparent)]
1252#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
1253pub struct StructureType(pub i32);
1254impl StructureType {
1255 pub const fn from_raw(value: i32) -> Self {
1256 Self(value)
1257 }
1258
1259 pub const fn as_raw(self) -> i32 {
1260 self.0
1261 }
1262
1263 pub const fn empty() -> Self {
1264 Self(0)
1265 }
1266
1267 pub const APPLICATION_INFO: Self = Self(0);
1268 pub const INSTANCE_CREATE_INFO: Self = Self(1);
1269 pub const DEVICE_QUEUE_CREATE_INFO: Self = Self(2);
1270 pub const DEVICE_CREATE_INFO: Self = Self(3);
1271 pub const SUBMIT_INFO: Self = Self(4);
1272 pub const MEMORY_ALLOCATE_INFO: Self = Self(5);
1273 pub const MAPPED_MEMORY_RANGE: Self = Self(6);
1274 pub const BIND_SPARSE_INFO: Self = Self(7);
1275 pub const FENCE_CREATE_INFO: Self = Self(8);
1276 pub const SEMAPHORE_CREATE_INFO: Self = Self(9);
1277 pub const EVENT_CREATE_INFO: Self = Self(10);
1278 pub const QUERY_POOL_CREATE_INFO: Self = Self(11);
1279 pub const BUFFER_CREATE_INFO: Self = Self(12);
1280 pub const BUFFER_VIEW_CREATE_INFO: Self = Self(13);
1281 pub const IMAGE_CREATE_INFO: Self = Self(14);
1282 pub const IMAGE_VIEW_CREATE_INFO: Self = Self(15);
1283 pub const SHADER_MODULE_CREATE_INFO: Self = Self(16);
1284 pub const PIPELINE_CACHE_CREATE_INFO: Self = Self(17);
1285 pub const PIPELINE_SHADER_STAGE_CREATE_INFO: Self = Self(18);
1286 pub const PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: Self = Self(19);
1287 pub const PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: Self = Self(20);
1288 pub const PIPELINE_TESSELLATION_STATE_CREATE_INFO: Self = Self(21);
1289 pub const PIPELINE_VIEWPORT_STATE_CREATE_INFO: Self = Self(22);
1290 pub const PIPELINE_RASTERIZATION_STATE_CREATE_INFO: Self = Self(23);
1291 pub const PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: Self = Self(24);
1292 pub const PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: Self = Self(25);
1293 pub const PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: Self = Self(26);
1294 pub const PIPELINE_DYNAMIC_STATE_CREATE_INFO: Self = Self(27);
1295 pub const GRAPHICS_PIPELINE_CREATE_INFO: Self = Self(28);
1296 pub const COMPUTE_PIPELINE_CREATE_INFO: Self = Self(29);
1297 pub const PIPELINE_LAYOUT_CREATE_INFO: Self = Self(30);
1298 pub const SAMPLER_CREATE_INFO: Self = Self(31);
1299 pub const DESCRIPTOR_SET_LAYOUT_CREATE_INFO: Self = Self(32);
1300 pub const DESCRIPTOR_POOL_CREATE_INFO: Self = Self(33);
1301 pub const DESCRIPTOR_SET_ALLOCATE_INFO: Self = Self(34);
1302 pub const WRITE_DESCRIPTOR_SET: Self = Self(35);
1303 pub const COPY_DESCRIPTOR_SET: Self = Self(36);
1304 pub const FRAMEBUFFER_CREATE_INFO: Self = Self(37);
1305 pub const RENDER_PASS_CREATE_INFO: Self = Self(38);
1306 pub const COMMAND_POOL_CREATE_INFO: Self = Self(39);
1307 pub const COMMAND_BUFFER_ALLOCATE_INFO: Self = Self(40);
1308 pub const COMMAND_BUFFER_INHERITANCE_INFO: Self = Self(41);
1309 pub const COMMAND_BUFFER_BEGIN_INFO: Self = Self(42);
1310 pub const RENDER_PASS_BEGIN_INFO: Self = Self(43);
1311 pub const BUFFER_MEMORY_BARRIER: Self = Self(44);
1312 pub const IMAGE_MEMORY_BARRIER: Self = Self(45);
1313 pub const MEMORY_BARRIER: Self = Self(46);
1314 pub const LOADER_INSTANCE_CREATE_INFO: Self = Self(47);
1315 pub const LOADER_DEVICE_CREATE_INFO: Self = Self(48);
1316 pub const BIND_BUFFER_MEMORY_INFO: Self = Self(1000157000);
1317 pub const BIND_IMAGE_MEMORY_INFO: Self = Self(1000157001);
1318 pub const MEMORY_DEDICATED_REQUIREMENTS: Self = Self(1000127000);
1319 pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = Self(1000127001);
1320 pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = Self(1000060000);
1321 pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = Self(1000060004);
1322 pub const DEVICE_GROUP_SUBMIT_INFO: Self = Self(1000060005);
1323 pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = Self(1000060006);
1324 pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = Self(1000060013);
1325 pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = Self(1000060014);
1326 pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = Self(1000070000);
1327 pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = Self(1000070001);
1328 pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146000);
1329 pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146001);
1330 pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146002);
1331 pub const MEMORY_REQUIREMENTS_2: Self = Self(1000146003);
1332 pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = Self(1000146004);
1333 pub const PHYSICAL_DEVICE_FEATURES_2: Self = Self(1000059000);
1334 pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = Self(1000059001);
1335 pub const FORMAT_PROPERTIES_2: Self = Self(1000059002);
1336 pub const IMAGE_FORMAT_PROPERTIES_2: Self = Self(1000059003);
1337 pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = Self(1000059004);
1338 pub const QUEUE_FAMILY_PROPERTIES_2: Self = Self(1000059005);
1339 pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = Self(1000059006);
1340 pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = Self(1000059007);
1341 pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = Self(1000059008);
1342 pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = Self(1000117002);
1343 pub const PROTECTED_SUBMIT_INFO: Self = Self(1000145000);
1344 pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = Self(1000145001);
1345 pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = Self(1000145002);
1346 pub const DEVICE_QUEUE_INFO_2: Self = Self(1000145003);
1347 pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = Self(1000071000);
1348 pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = Self(1000071001);
1349 pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = Self(1000071002);
1350 pub const EXTERNAL_BUFFER_PROPERTIES: Self = Self(1000071003);
1351 pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = Self(1000071004);
1352 pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = Self(1000072000);
1353 pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = Self(1000072001);
1354 pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = Self(1000072002);
1355 pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = Self(1000112000);
1356 pub const EXTERNAL_FENCE_PROPERTIES: Self = Self(1000112001);
1357 pub const EXPORT_FENCE_CREATE_INFO: Self = Self(1000113000);
1358 pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = Self(1000077000);
1359 pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = Self(1000076000);
1360 pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = Self(1000076001);
1361 pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = Self(1000094000);
1362 pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = Self(1000083000);
1363 pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = Self(1000120000);
1364 pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self = Self(1000120000);
1365 pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = Self(1000085000);
1366 pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = Self(1000168000);
1367 pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = Self(1000168001);
1368 pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = Self(1000156000);
1369 pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = Self(1000156001);
1370 pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = Self(1000156002);
1371 pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = Self(1000156003);
1372 pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = Self(1000156004);
1373 pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = Self(1000156005);
1374 pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = Self(1000060003);
1375 pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = Self(1000117000);
1376 pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = Self(1000117001);
1377 pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = Self(1000117003);
1378 pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = Self(1000053000);
1379 pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = Self(1000053001);
1380 pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = Self(1000053002);
1381 pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: Self = Self(1000063000);
1382 pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = Self(1000063000);
1383 pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES: Self = Self(1000196000);
1384 pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = Self(49);
1385 pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = Self(50);
1386 pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = Self(51);
1387 pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = Self(52);
1388 pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = Self(1000147000);
1389 pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: Self = Self(1000211000);
1390 pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: Self = Self(1000261000);
1391 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: Self = Self(1000207000);
1392 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: Self = Self(1000207001);
1393 pub const SEMAPHORE_TYPE_CREATE_INFO: Self = Self(1000207002);
1394 pub const TIMELINE_SEMAPHORE_SUBMIT_INFO: Self = Self(1000207003);
1395 pub const SEMAPHORE_WAIT_INFO: Self = Self(1000207004);
1396 pub const SEMAPHORE_SIGNAL_INFO: Self = Self(1000207005);
1397 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: Self = Self(1000257000);
1398 pub const BUFFER_DEVICE_ADDRESS_INFO: Self = Self(1000244001);
1399 pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: Self = Self(1000257002);
1400 pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: Self = Self(1000257003);
1401 pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: Self = Self(1000257004);
1402 pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: Self = Self(1000177000);
1403 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: Self = Self(1000180000);
1404 pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: Self = Self(1000082000);
1405 pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: Self = Self(1000197000);
1406 pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: Self = Self(1000161000);
1407 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: Self = Self(1000161001);
1408 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: Self = Self(1000161002);
1409 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: Self = Self(1000161003);
1410 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: Self = Self(1000161004);
1411 pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: Self = Self(1000221000);
1412 pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: Self = Self(1000130000);
1413 pub const SAMPLER_REDUCTION_MODE_CREATE_INFO: Self = Self(1000130001);
1414 pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: Self = Self(1000253000);
1415 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: Self = Self(1000175000);
1416 pub const ATTACHMENT_DESCRIPTION_2: Self = Self(1000109000);
1417 pub const ATTACHMENT_REFERENCE_2: Self = Self(1000109001);
1418 pub const SUBPASS_DESCRIPTION_2: Self = Self(1000109002);
1419 pub const SUBPASS_DEPENDENCY_2: Self = Self(1000109003);
1420 pub const RENDER_PASS_CREATE_INFO_2: Self = Self(1000109004);
1421 pub const SUBPASS_BEGIN_INFO: Self = Self(1000109005);
1422 pub const SUBPASS_END_INFO: Self = Self(1000109006);
1423 pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: Self = Self(1000199000);
1424 pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: Self = Self(1000199001);
1425 pub const IMAGE_STENCIL_USAGE_CREATE_INFO: Self = Self(1000246000);
1426 pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: Self = Self(1000108000);
1427 pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: Self = Self(1000108001);
1428 pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: Self = Self(1000108002);
1429 pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO: Self = Self(1000108003);
1430 pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: Self = Self(1000241000);
1431 pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT: Self = Self(1000241001);
1432 pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: Self = Self(1000241002);
1433 pub const PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: Self = Self(53);
1434 pub const PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: Self = Self(54);
1435 pub const PHYSICAL_DEVICE_TOOL_PROPERTIES: Self = Self(1000245000);
1436 pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: Self = Self(1000295000);
1437 pub const DEVICE_PRIVATE_DATA_CREATE_INFO: Self = Self(1000295001);
1438 pub const PRIVATE_DATA_SLOT_CREATE_INFO: Self = Self(1000295002);
1439 pub const MEMORY_BARRIER_2: Self = Self(1000314000);
1440 pub const BUFFER_MEMORY_BARRIER_2: Self = Self(1000314001);
1441 pub const IMAGE_MEMORY_BARRIER_2: Self = Self(1000314002);
1442 pub const DEPENDENCY_INFO: Self = Self(1000314003);
1443 pub const SUBMIT_INFO_2: Self = Self(1000314004);
1444 pub const SEMAPHORE_SUBMIT_INFO: Self = Self(1000314005);
1445 pub const COMMAND_BUFFER_SUBMIT_INFO: Self = Self(1000314006);
1446 pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: Self = Self(1000314007);
1447 pub const COPY_BUFFER_INFO_2: Self = Self(1000337000);
1448 pub const COPY_IMAGE_INFO_2: Self = Self(1000337001);
1449 pub const COPY_BUFFER_TO_IMAGE_INFO_2: Self = Self(1000337002);
1450 pub const COPY_IMAGE_TO_BUFFER_INFO_2: Self = Self(1000337003);
1451 pub const BUFFER_COPY_2: Self = Self(1000337006);
1452 pub const IMAGE_COPY_2: Self = Self(1000337007);
1453 pub const BUFFER_IMAGE_COPY_2: Self = Self(1000337009);
1454 pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: Self = Self(1000066000);
1455 pub const FORMAT_PROPERTIES_3: Self = Self(1000360000);
1456 pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: Self = Self(1000413000);
1457 pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: Self = Self(1000413001);
1458 pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS: Self = Self(1000413002);
1459 pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS: Self = Self(1000413003);
1460 pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO: Self = Self(1000192000);
1461 pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: Self = Self(1000215000);
1462 pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: Self = Self(1000276000);
1463 pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: Self = Self(1000297000);
1464 pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: Self = Self(1000325000);
1465 pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: Self = Self(1000335000);
1466 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: Self = Self(1000225000);
1467 pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: Self = Self(1000225001);
1468 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: Self = Self(1000225002);
1469 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: Self = Self(1000138000);
1470 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: Self = Self(1000138001);
1471 pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: Self = Self(1000138002);
1472 pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: Self = Self(1000138003);
1473 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: Self = Self(1000280000);
1474 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: Self = Self(1000280001);
1475 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: Self = Self(1000281001);
1476 pub const BLIT_IMAGE_INFO_2: Self = Self(1000337004);
1477 pub const RESOLVE_IMAGE_INFO_2: Self = Self(1000337005);
1478 pub const IMAGE_BLIT_2: Self = Self(1000337008);
1479 pub const IMAGE_RESOLVE_2: Self = Self(1000337010);
1480 pub const RENDERING_INFO: Self = Self(1000044000);
1481 pub const RENDERING_ATTACHMENT_INFO: Self = Self(1000044001);
1482 pub const PIPELINE_RENDERING_CREATE_INFO: Self = Self(1000044002);
1483 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: Self = Self(1000044003);
1484 pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: Self = Self(1000044004);
1485 pub const PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: Self = Self(55);
1486 pub const PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: Self = Self(56);
1487 pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: Self = Self(1000174000);
1488 pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: Self = Self(1000388000);
1489 pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: Self = Self(1000388001);
1490 pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: Self = Self(1000265000);
1491 pub const MEMORY_MAP_INFO: Self = Self(1000271000);
1492 pub const MEMORY_UNMAP_INFO: Self = Self(1000271001);
1493 pub const PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: Self = Self(1000470000);
1494 pub const PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: Self = Self(1000470001);
1495 pub const DEVICE_IMAGE_SUBRESOURCE_INFO: Self = Self(1000470004);
1496 pub const SUBRESOURCE_LAYOUT_2: Self = Self(1000338002);
1497 pub const IMAGE_SUBRESOURCE_2: Self = Self(1000338003);
1498 pub const BUFFER_USAGE_FLAGS_2_CREATE_INFO: Self = Self(1000470006);
1499 pub const PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: Self = Self(1000545000);
1500 pub const PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: Self = Self(1000545001);
1501 pub const BIND_MEMORY_STATUS: Self = Self(1000545002);
1502 pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: Self = Self(1000270000);
1503 pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: Self = Self(1000270001);
1504 pub const MEMORY_TO_IMAGE_COPY: Self = Self(1000270002);
1505 pub const IMAGE_TO_MEMORY_COPY: Self = Self(1000270003);
1506 pub const COPY_IMAGE_TO_MEMORY_INFO: Self = Self(1000270004);
1507 pub const COPY_MEMORY_TO_IMAGE_INFO: Self = Self(1000270005);
1508 pub const HOST_IMAGE_LAYOUT_TRANSITION_INFO: Self = Self(1000270006);
1509 pub const COPY_IMAGE_TO_IMAGE_INFO: Self = Self(1000270007);
1510 pub const SUBRESOURCE_HOST_MEMCPY_SIZE: Self = Self(1000270008);
1511 pub const HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: Self = Self(1000270009);
1512 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: Self = Self(1000416000);
1513 pub const PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: Self = Self(1000528000);
1514 pub const PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: Self = Self(1000544000);
1515 pub const PIPELINE_CREATE_FLAGS_2_CREATE_INFO: Self = Self(1000470005);
1516 pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: Self = Self(1000080000);
1517 pub const BIND_DESCRIPTOR_SETS_INFO: Self = Self(1000545003);
1518 pub const PUSH_CONSTANTS_INFO: Self = Self(1000545004);
1519 pub const PUSH_DESCRIPTOR_SET_INFO: Self = Self(1000545005);
1520 pub const PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: Self = Self(1000545006);
1521 pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: Self = Self(1000466000);
1522 pub const PIPELINE_ROBUSTNESS_CREATE_INFO: Self = Self(1000068000);
1523 pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: Self = Self(1000068001);
1524 pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: Self = Self(1000068002);
1525 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: Self = Self(1000259000);
1526 pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: Self = Self(1000259001);
1527 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: Self = Self(1000259002);
1528 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: Self = Self(1000525000);
1529 pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: Self = Self(1000190001);
1530 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: Self = Self(1000190002);
1531 pub const RENDERING_AREA_INFO: Self = Self(1000470003);
1532 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: Self = Self(1000232000);
1533 pub const RENDERING_ATTACHMENT_LOCATION_INFO: Self = Self(1000232001);
1534 pub const RENDERING_INPUT_ATTACHMENT_INDEX_INFO: Self = Self(1000232002);
1535 pub const SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1000001000);
1536 pub const PRESENT_INFO_KHR: Self = Self(1000001001);
1537 pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = Self(1000060007);
1538 pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1000060008);
1539 pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = Self(1000060009);
1540 pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = Self(1000060010);
1541 pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = Self(1000060011);
1542 pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1000060012);
1543 pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = Self(1000002000);
1544 pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = Self(1000002001);
1545 pub const DISPLAY_PRESENT_INFO_KHR: Self = Self(1000003000);
1546 #[cfg(feature = "platform-xlib")]
1547 pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = Self(1000004000);
1548 #[cfg(feature = "platform-xcb")]
1549 pub const XCB_SURFACE_CREATE_INFO_KHR: Self = Self(1000005000);
1550 #[cfg(feature = "platform-wayland")]
1551 pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = Self(1000006000);
1552 #[cfg(feature = "platform-android")]
1553 pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = Self(1000008000);
1554 #[cfg(feature = "platform-win32")]
1555 pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = Self(1000009000);
1556 pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = Self(1000011000);
1557 pub const DEBUG_REPORT_CREATE_INFO_EXT: Self = Self(1000011000);
1558 pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = Self(1000018000);
1559 pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = Self(1000022000);
1560 pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = Self(1000022001);
1561 pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = Self(1000022002);
1562 pub const VIDEO_PROFILE_INFO_KHR: Self = Self(1000023000);
1563 pub const VIDEO_CAPABILITIES_KHR: Self = Self(1000023001);
1564 pub const VIDEO_PICTURE_RESOURCE_INFO_KHR: Self = Self(1000023002);
1565 pub const VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: Self = Self(1000023003);
1566 pub const BIND_VIDEO_SESSION_MEMORY_INFO_KHR: Self = Self(1000023004);
1567 pub const VIDEO_SESSION_CREATE_INFO_KHR: Self = Self(1000023005);
1568 pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1000023006);
1569 pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: Self = Self(1000023007);
1570 pub const VIDEO_BEGIN_CODING_INFO_KHR: Self = Self(1000023008);
1571 pub const VIDEO_END_CODING_INFO_KHR: Self = Self(1000023009);
1572 pub const VIDEO_CODING_CONTROL_INFO_KHR: Self = Self(1000023010);
1573 pub const VIDEO_REFERENCE_SLOT_INFO_KHR: Self = Self(1000023011);
1574 pub const QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: Self = Self(1000023012);
1575 pub const VIDEO_PROFILE_LIST_INFO_KHR: Self = Self(1000023013);
1576 pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: Self = Self(1000023014);
1577 pub const VIDEO_FORMAT_PROPERTIES_KHR: Self = Self(1000023015);
1578 pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: Self = Self(1000023016);
1579 pub const VIDEO_DECODE_INFO_KHR: Self = Self(1000024000);
1580 pub const VIDEO_DECODE_CAPABILITIES_KHR: Self = Self(1000024001);
1581 pub const VIDEO_DECODE_USAGE_INFO_KHR: Self = Self(1000024002);
1582 pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = Self(1000026000);
1583 pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = Self(1000026001);
1584 pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = Self(1000026002);
1585 pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: Self = Self(1000028000);
1586 pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: Self = Self(1000028001);
1587 pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: Self = Self(1000028002);
1588 pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1000029000);
1589 pub const CU_FUNCTION_CREATE_INFO_NVX: Self = Self(1000029001);
1590 pub const CU_LAUNCH_INFO_NVX: Self = Self(1000029002);
1591 pub const CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: Self = Self(1000029004);
1592 pub const IMAGE_VIEW_HANDLE_INFO_NVX: Self = Self(1000030000);
1593 pub const IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: Self = Self(1000030001);
1594 pub const VIDEO_ENCODE_H264_CAPABILITIES_KHR: Self = Self(1000038000);
1595 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1000038001);
1596 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1000038002);
1597 pub const VIDEO_ENCODE_H264_PICTURE_INFO_KHR: Self = Self(1000038003);
1598 pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: Self = Self(1000038004);
1599 pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: Self = Self(1000038005);
1600 pub const VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: Self = Self(1000038006);
1601 pub const VIDEO_ENCODE_H264_PROFILE_INFO_KHR: Self = Self(1000038007);
1602 pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: Self = Self(1000038008);
1603 pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1000038009);
1604 pub const VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: Self = Self(1000038010);
1605 pub const VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: Self = Self(1000038011);
1606 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: Self = Self(1000038012);
1607 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: Self = Self(1000038013);
1608 pub const VIDEO_ENCODE_H265_CAPABILITIES_KHR: Self = Self(1000039000);
1609 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1000039001);
1610 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1000039002);
1611 pub const VIDEO_ENCODE_H265_PICTURE_INFO_KHR: Self = Self(1000039003);
1612 pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: Self = Self(1000039004);
1613 pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: Self = Self(1000039005);
1614 pub const VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: Self = Self(1000039006);
1615 pub const VIDEO_ENCODE_H265_PROFILE_INFO_KHR: Self = Self(1000039007);
1616 pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: Self = Self(1000039009);
1617 pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1000039010);
1618 pub const VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: Self = Self(1000039011);
1619 pub const VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: Self = Self(1000039012);
1620 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: Self = Self(1000039013);
1621 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: Self = Self(1000039014);
1622 pub const VIDEO_DECODE_H264_CAPABILITIES_KHR: Self = Self(1000040000);
1623 pub const VIDEO_DECODE_H264_PICTURE_INFO_KHR: Self = Self(1000040001);
1624 pub const VIDEO_DECODE_H264_PROFILE_INFO_KHR: Self = Self(1000040003);
1625 pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1000040004);
1626 pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1000040005);
1627 pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: Self = Self(1000040006);
1628 pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = Self(1000041000);
1629 pub const RENDERING_INFO_KHR: Self = Self(1000044000);
1630 pub const RENDERING_ATTACHMENT_INFO_KHR: Self = Self(1000044001);
1631 pub const PIPELINE_RENDERING_CREATE_INFO_KHR: Self = Self(1000044002);
1632 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: Self = Self(1000044003);
1633 pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: Self = Self(1000044004);
1634 #[cfg(feature = "platform-ggp")]
1635 pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: Self = Self(1000049000);
1636 pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: Self = Self(1000050000);
1637 pub const RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: Self = Self(1000053000);
1638 pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: Self = Self(1000053001);
1639 pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: Self = Self(1000053002);
1640 pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = Self(1000056000);
1641 pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = Self(1000056001);
1642 #[cfg(feature = "platform-win32")]
1643 pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1000057000);
1644 #[cfg(feature = "platform-win32")]
1645 pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1000057001);
1646 #[cfg(feature = "platform-win32")]
1647 pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = Self(1000058000);
1648 pub const PHYSICAL_DEVICE_FEATURES_2_KHR: Self = Self(1000059000);
1649 pub const PHYSICAL_DEVICE_PROPERTIES_2_KHR: Self = Self(1000059001);
1650 pub const FORMAT_PROPERTIES_2_KHR: Self = Self(1000059002);
1651 pub const IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self(1000059003);
1652 pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: Self = Self(1000059004);
1653 pub const QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self(1000059005);
1654 pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: Self = Self(1000059006);
1655 pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self(1000059007);
1656 pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: Self = Self(1000059008);
1657 pub const MEMORY_ALLOCATE_FLAGS_INFO_KHR: Self = Self(1000060000);
1658 pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: Self = Self(1000060003);
1659 pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: Self = Self(1000060004);
1660 pub const DEVICE_GROUP_SUBMIT_INFO_KHR: Self = Self(1000060005);
1661 pub const DEVICE_GROUP_BIND_SPARSE_INFO_KHR: Self = Self(1000060006);
1662 pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: Self = Self(1000060013);
1663 pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: Self = Self(1000060014);
1664 pub const VALIDATION_FLAGS_EXT: Self = Self(1000061000);
1665 #[cfg(feature = "platform-vi")]
1666 pub const VI_SURFACE_CREATE_INFO_NN: Self = Self(1000062000);
1667 pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: Self = Self(1000066000);
1668 pub const IMAGE_VIEW_ASTC_DECODE_MODE_EXT: Self = Self(1000067000);
1669 pub const PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: Self = Self(1000067001);
1670 pub const PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: Self = Self(1000068000);
1671 pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: Self = Self(1000068001);
1672 pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: Self = Self(1000068002);
1673 pub const PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: Self = Self(1000070000);
1674 pub const DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: Self = Self(1000070001);
1675 pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: Self = Self(1000071000);
1676 pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: Self = Self(1000071001);
1677 pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: Self = Self(1000071002);
1678 pub const EXTERNAL_BUFFER_PROPERTIES_KHR: Self = Self(1000071003);
1679 pub const PHYSICAL_DEVICE_ID_PROPERTIES_KHR: Self = Self(1000071004);
1680 pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: Self = Self(1000072000);
1681 pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: Self = Self(1000072001);
1682 pub const EXPORT_MEMORY_ALLOCATE_INFO_KHR: Self = Self(1000072002);
1683 #[cfg(feature = "platform-win32")]
1684 pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1000073000);
1685 #[cfg(feature = "platform-win32")]
1686 pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1000073001);
1687 #[cfg(feature = "platform-win32")]
1688 pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = Self(1000073002);
1689 #[cfg(feature = "platform-win32")]
1690 pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1000073003);
1691 pub const IMPORT_MEMORY_FD_INFO_KHR: Self = Self(1000074000);
1692 pub const MEMORY_FD_PROPERTIES_KHR: Self = Self(1000074001);
1693 pub const MEMORY_GET_FD_INFO_KHR: Self = Self(1000074002);
1694 #[cfg(feature = "platform-win32")]
1695 pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = Self(1000075000);
1696 pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: Self = Self(1000076000);
1697 pub const EXTERNAL_SEMAPHORE_PROPERTIES_KHR: Self = Self(1000076001);
1698 pub const EXPORT_SEMAPHORE_CREATE_INFO_KHR: Self = Self(1000077000);
1699 #[cfg(feature = "platform-win32")]
1700 pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1000078000);
1701 #[cfg(feature = "platform-win32")]
1702 pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1000078001);
1703 #[cfg(feature = "platform-win32")]
1704 pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = Self(1000078002);
1705 #[cfg(feature = "platform-win32")]
1706 pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1000078003);
1707 pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = Self(1000079000);
1708 pub const SEMAPHORE_GET_FD_INFO_KHR: Self = Self(1000079001);
1709 pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = Self(1000080000);
1710 pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: Self = Self(1000081000);
1711 pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: Self = Self(1000081001);
1712 pub const CONDITIONAL_RENDERING_BEGIN_INFO_EXT: Self = Self(1000081002);
1713 pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: Self = Self(1000082000);
1714 pub const PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: Self = Self(1000082000);
1715 pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: Self = Self(1000083000);
1716 pub const PRESENT_REGIONS_KHR: Self = Self(1000084000);
1717 pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: Self = Self(1000085000);
1718 pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = Self(1000087000);
1719 pub const SURFACE_CAPABILITIES_2_EXT: Self = Self(1000090000);
1720 pub const SURFACE_CAPABILITIES2_EXT: Self = Self(1000090000);
1721 pub const DISPLAY_POWER_INFO_EXT: Self = Self(1000091000);
1722 pub const DEVICE_EVENT_INFO_EXT: Self = Self(1000091001);
1723 pub const DISPLAY_EVENT_INFO_EXT: Self = Self(1000091002);
1724 pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = Self(1000091003);
1725 pub const PRESENT_TIMES_INFO_GOOGLE: Self = Self(1000092000);
1726 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self = Self(1000097000);
1727 pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: Self = Self(1000044009);
1728 pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = Self(1000098000);
1729 pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = Self(1000099000);
1730 pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = Self(1000099001);
1731 pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1000101000);
1732 pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = Self(1000101001);
1733 pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: Self = Self(1000102000);
1734 pub const PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: Self = Self(1000102001);
1735 pub const HDR_METADATA_EXT: Self = Self(1000105000);
1736 pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: Self = Self(1000108000);
1737 pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: Self = Self(1000108001);
1738 pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: Self = Self(1000108002);
1739 pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: Self = Self(1000108003);
1740 pub const ATTACHMENT_DESCRIPTION_2_KHR: Self = Self(1000109000);
1741 pub const ATTACHMENT_REFERENCE_2_KHR: Self = Self(1000109001);
1742 pub const SUBPASS_DESCRIPTION_2_KHR: Self = Self(1000109002);
1743 pub const SUBPASS_DEPENDENCY_2_KHR: Self = Self(1000109003);
1744 pub const RENDER_PASS_CREATE_INFO_2_KHR: Self = Self(1000109004);
1745 pub const SUBPASS_BEGIN_INFO_KHR: Self = Self(1000109005);
1746 pub const SUBPASS_END_INFO_KHR: Self = Self(1000109006);
1747 pub const PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: Self = Self(1000110000);
1748 pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = Self(1000111000);
1749 pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: Self = Self(1000112000);
1750 pub const EXTERNAL_FENCE_PROPERTIES_KHR: Self = Self(1000112001);
1751 pub const EXPORT_FENCE_CREATE_INFO_KHR: Self = Self(1000113000);
1752 #[cfg(feature = "platform-win32")]
1753 pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1000114000);
1754 #[cfg(feature = "platform-win32")]
1755 pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1000114001);
1756 #[cfg(feature = "platform-win32")]
1757 pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1000114002);
1758 pub const IMPORT_FENCE_FD_INFO_KHR: Self = Self(1000115000);
1759 pub const FENCE_GET_FD_INFO_KHR: Self = Self(1000115001);
1760 pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: Self = Self(1000116000);
1761 pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: Self = Self(1000116001);
1762 pub const QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: Self = Self(1000116002);
1763 pub const PERFORMANCE_QUERY_SUBMIT_INFO_KHR: Self = Self(1000116003);
1764 pub const ACQUIRE_PROFILING_LOCK_INFO_KHR: Self = Self(1000116004);
1765 pub const PERFORMANCE_COUNTER_KHR: Self = Self(1000116005);
1766 pub const PERFORMANCE_COUNTER_DESCRIPTION_KHR: Self = Self(1000116006);
1767 pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: Self = Self(1000117000);
1768 pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: Self = Self(1000117001);
1769 pub const IMAGE_VIEW_USAGE_CREATE_INFO_KHR: Self = Self(1000117002);
1770 pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: Self = Self(1000117003);
1771 pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = Self(1000119000);
1772 pub const SURFACE_CAPABILITIES_2_KHR: Self = Self(1000119001);
1773 pub const SURFACE_FORMAT_2_KHR: Self = Self(1000119002);
1774 pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: Self = Self(1000120000);
1775 pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: Self = Self(1000120000);
1776 pub const DISPLAY_PROPERTIES_2_KHR: Self = Self(1000121000);
1777 pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = Self(1000121001);
1778 pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = Self(1000121002);
1779 pub const DISPLAY_PLANE_INFO_2_KHR: Self = Self(1000121003);
1780 pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = Self(1000121004);
1781 #[cfg(feature = "platform-ios")]
1782 pub const IOS_SURFACE_CREATE_INFO_MVK: Self = Self(1000122000);
1783 #[cfg(feature = "platform-macos")]
1784 pub const MACOS_SURFACE_CREATE_INFO_MVK: Self = Self(1000123000);
1785 pub const MEMORY_DEDICATED_REQUIREMENTS_KHR: Self = Self(1000127000);
1786 pub const MEMORY_DEDICATED_ALLOCATE_INFO_KHR: Self = Self(1000127001);
1787 pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = Self(1000128000);
1788 pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = Self(1000128001);
1789 pub const DEBUG_UTILS_LABEL_EXT: Self = Self(1000128002);
1790 pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = Self(1000128003);
1791 pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = Self(1000128004);
1792 #[cfg(feature = "platform-android")]
1793 pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = Self(1000129000);
1794 #[cfg(feature = "platform-android")]
1795 pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = Self(1000129001);
1796 #[cfg(feature = "platform-android")]
1797 pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = Self(1000129002);
1798 #[cfg(feature = "platform-android")]
1799 pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1000129003);
1800 #[cfg(feature = "platform-android")]
1801 pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1000129004);
1802 #[cfg(feature = "platform-android")]
1803 pub const EXTERNAL_FORMAT_ANDROID: Self = Self(1000129005);
1804 #[cfg(feature = "platform-android")]
1805 pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: Self = Self(1000129006);
1806 pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self = Self(1000130000);
1807 pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self = Self(1000130001);
1808 pub const PHYSICAL_DEVICE_GPA_FEATURES_AMD: Self = Self(1000133000);
1809 pub const PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: Self = Self(1000133001);
1810 pub const GPA_SAMPLE_BEGIN_INFO_AMD: Self = Self(1000133002);
1811 pub const GPA_SESSION_CREATE_INFO_AMD: Self = Self(1000133003);
1812 pub const GPA_DEVICE_CLOCK_MODE_INFO_AMD: Self = Self(1000133004);
1813 pub const PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: Self = Self(1000133005);
1814 pub const GPA_DEVICE_GET_CLOCK_INFO_AMD: Self = Self(1000133006);
1815 #[cfg(feature = "provisional")]
1816 pub const PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: Self = Self(1000134000);
1817 #[cfg(feature = "provisional")]
1818 pub const PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: Self = Self(1000134001);
1819 #[cfg(feature = "provisional")]
1820 pub const EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: Self = Self(1000134002);
1821 #[cfg(feature = "provisional")]
1822 pub const EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: Self = Self(1000134003);
1823 #[cfg(feature = "provisional")]
1824 pub const PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: Self = Self(1000134004);
1825 pub const TEXEL_BUFFER_DESCRIPTOR_INFO_EXT: Self = Self(1000135000);
1826 pub const IMAGE_DESCRIPTOR_INFO_EXT: Self = Self(1000135001);
1827 pub const RESOURCE_DESCRIPTOR_INFO_EXT: Self = Self(1000135002);
1828 pub const BIND_HEAP_INFO_EXT: Self = Self(1000135003);
1829 pub const PUSH_DATA_INFO_EXT: Self = Self(1000135004);
1830 pub const DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT: Self = Self(1000135005);
1831 pub const SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT: Self = Self(1000135006);
1832 pub const OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: Self = Self(1000135007);
1833 pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT: Self = Self(1000135008);
1834 pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: Self = Self(1000135009);
1835 pub const COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT: Self = Self(1000135010);
1836 pub const SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT: Self = Self(1000135011);
1837 pub const INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV: Self = Self(1000135012);
1838 pub const SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1000135013);
1839 pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM: Self = Self(1000135014);
1840 pub const ATTACHMENT_SAMPLE_COUNT_INFO_AMD: Self = Self(1000044008);
1841 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: Self = Self(1000138000);
1842 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: Self = Self(1000138001);
1843 pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: Self = Self(1000138002);
1844 pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: Self = Self(1000138003);
1845 pub const PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: Self = Self(1000141000);
1846 pub const SAMPLE_LOCATIONS_INFO_EXT: Self = Self(1000143000);
1847 pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = Self(1000143001);
1848 pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = Self(1000143002);
1849 pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = Self(1000143003);
1850 pub const MULTISAMPLE_PROPERTIES_EXT: Self = Self(1000143004);
1851 pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self(1000146000);
1852 pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self(1000146001);
1853 pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self(1000146002);
1854 pub const MEMORY_REQUIREMENTS_2_KHR: Self = Self(1000146003);
1855 pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: Self = Self(1000146004);
1856 pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = Self(1000147000);
1857 pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = Self(1000148000);
1858 pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = Self(1000148001);
1859 pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = Self(1000148002);
1860 pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = Self(1000149000);
1861 pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1000150007);
1862 pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: Self = Self(1000150000);
1863 pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: Self = Self(1000150002);
1864 pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: Self = Self(1000150003);
1865 pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: Self = Self(1000150004);
1866 pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: Self = Self(1000150005);
1867 pub const ACCELERATION_STRUCTURE_GEOMETRY_KHR: Self = Self(1000150006);
1868 pub const ACCELERATION_STRUCTURE_VERSION_INFO_KHR: Self = Self(1000150009);
1869 pub const COPY_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1000150010);
1870 pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: Self = Self(1000150011);
1871 pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1000150012);
1872 pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: Self = Self(1000150013);
1873 pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: Self = Self(1000150014);
1874 pub const ACCELERATION_STRUCTURE_CREATE_INFO_KHR: Self = Self(1000150017);
1875 pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: Self = Self(1000150020);
1876 pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: Self = Self(1000347000);
1877 pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: Self = Self(1000347001);
1878 pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1000150015);
1879 pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1000150016);
1880 pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1000150018);
1881 pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: Self = Self(1000348013);
1882 pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = Self(1000152000);
1883 pub const ATTACHMENT_SAMPLE_COUNT_INFO_NV: Self = Self(1000044008);
1884 pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1000154000);
1885 pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: Self = Self(1000154001);
1886 pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self = Self(1000156000);
1887 pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = Self(1000156001);
1888 pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = Self(1000156002);
1889 pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self = Self(1000156003);
1890 pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self = Self(1000156004);
1891 pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self = Self(1000156005);
1892 pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = Self(1000157000);
1893 pub const BIND_IMAGE_MEMORY_INFO_KHR: Self = Self(1000157001);
1894 pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1000158000);
1895 pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1000158002);
1896 pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: Self = Self(1000158003);
1897 pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: Self = Self(1000158004);
1898 pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1000158005);
1899 pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: Self = Self(1000158006);
1900 pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1000160000);
1901 pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1000160001);
1902 pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self = Self(1000161000);
1903 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self = Self(1000161001);
1904 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self = Self(1000161002);
1905 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self = Self(1000161003);
1906 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self = Self(1000161004);
1907 #[cfg(feature = "provisional")]
1908 pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: Self = Self(1000163000);
1909 #[cfg(feature = "provisional")]
1910 pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: Self = Self(1000163001);
1911 pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1000164000);
1912 pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1000164001);
1913 pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1000164002);
1914 pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: Self = Self(1000164005);
1915 pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1000165000);
1916 pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1000165001);
1917 pub const GEOMETRY_NV: Self = Self(1000165003);
1918 pub const GEOMETRY_TRIANGLES_NV: Self = Self(1000165004);
1919 pub const GEOMETRY_AABB_NV: Self = Self(1000165005);
1920 pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = Self(1000165006);
1921 pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = Self(1000165007);
1922 pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1000165008);
1923 pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1000165009);
1924 pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1000165011);
1925 pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1000165012);
1926 pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self(1000166000);
1927 pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: Self = Self(1000166001);
1928 pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: Self = Self(1000168000);
1929 pub const DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: Self = Self(1000168001);
1930 pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: Self = Self(1000170000);
1931 pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1000170001);
1932 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: Self = Self(1000172000);
1933 pub const PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: Self = Self(1000173000);
1934 pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = Self(1000174000);
1935 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: Self = Self(1000175000);
1936 pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: Self = Self(1000177000);
1937 pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1000178000);
1938 pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = Self(1000178001);
1939 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = Self(1000178002);
1940 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: Self = Self(1000180000);
1941 pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1000181000);
1942 pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1000183000);
1943 pub const CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1000184000);
1944 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1000185000);
1945 pub const VIDEO_DECODE_H265_CAPABILITIES_KHR: Self = Self(1000187000);
1946 pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1000187001);
1947 pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1000187002);
1948 pub const VIDEO_DECODE_H265_PROFILE_INFO_KHR: Self = Self(1000187003);
1949 pub const VIDEO_DECODE_H265_PICTURE_INFO_KHR: Self = Self(1000187004);
1950 pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: Self = Self(1000187005);
1951 pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: Self = Self(1000174000);
1952 pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: Self = Self(1000388000);
1953 pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: Self = Self(1000388001);
1954 pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1000189000);
1955 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = Self(1000190000);
1956 pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = Self(1000190001);
1957 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: Self = Self(1000190002);
1958 #[cfg(feature = "platform-ggp")]
1959 pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1000191000);
1960 pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1000192000);
1961 pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = Self(1000196000);
1962 pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self = Self(1000197000);
1963 pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self = Self(1000199000);
1964 pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self = Self(1000199001);
1965 pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: Self = Self(1000201000);
1966 pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1000202000);
1967 pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1000202001);
1968 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = Self(1000203000);
1969 pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self(1000204000);
1970 pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1000205000);
1971 pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: Self = Self(1000205002);
1972 pub const CHECKPOINT_DATA_NV: Self = Self(1000206000);
1973 pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: Self = Self(1000206001);
1974 pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: Self = Self(1000314008);
1975 pub const CHECKPOINT_DATA_2_NV: Self = Self(1000314009);
1976 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self = Self(1000207000);
1977 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self = Self(1000207001);
1978 pub const SEMAPHORE_TYPE_CREATE_INFO_KHR: Self = Self(1000207002);
1979 pub const TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: Self = Self(1000207003);
1980 pub const SEMAPHORE_WAIT_INFO_KHR: Self = Self(1000207004);
1981 pub const SEMAPHORE_SIGNAL_INFO_KHR: Self = Self(1000207005);
1982 pub const PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: Self = Self(1000208000);
1983 pub const SWAPCHAIN_TIMING_PROPERTIES_EXT: Self = Self(1000208001);
1984 pub const SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: Self = Self(1000208002);
1985 pub const PRESENT_TIMINGS_INFO_EXT: Self = Self(1000208003);
1986 pub const PRESENT_TIMING_INFO_EXT: Self = Self(1000208004);
1987 pub const PAST_PRESENTATION_TIMING_INFO_EXT: Self = Self(1000208005);
1988 pub const PAST_PRESENTATION_TIMING_PROPERTIES_EXT: Self = Self(1000208006);
1989 pub const PAST_PRESENTATION_TIMING_EXT: Self = Self(1000208007);
1990 pub const PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: Self = Self(1000208008);
1991 pub const SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1000208009);
1992 pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self(1000209000);
1993 pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: Self = Self(1000210000);
1994 pub const QUERY_POOL_CREATE_INFO_INTEL: Self = Self(1000210000);
1995 pub const INITIALIZE_PERFORMANCE_API_INFO_INTEL: Self = Self(1000210001);
1996 pub const PERFORMANCE_MARKER_INFO_INTEL: Self = Self(1000210002);
1997 pub const PERFORMANCE_STREAM_MARKER_INFO_INTEL: Self = Self(1000210003);
1998 pub const PERFORMANCE_OVERRIDE_INFO_INTEL: Self = Self(1000210004);
1999 pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: Self = Self(1000210005);
2000 pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: Self = Self(1000211000);
2001 pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1000212000);
2002 pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1000213000);
2003 pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: Self = Self(1000213001);
2004 #[cfg(feature = "platform-fuchsia")]
2005 pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1000214000);
2006 pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: Self = Self(1000215000);
2007 #[cfg(feature = "platform-metal")]
2008 pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1000217000);
2009 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1000218000);
2010 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1000218001);
2011 pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1000218002);
2012 pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: Self = Self(1000044007);
2013 pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: Self = Self(1000221000);
2014 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self = Self(1000225000);
2015 pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self = Self(1000225001);
2016 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self = Self(1000225002);
2017 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1000226000);
2018 pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: Self = Self(1000226001);
2019 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: Self = Self(1000226002);
2020 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: Self = Self(1000226003);
2021 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: Self = Self(1000226004);
2022 pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1000044006);
2023 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1000227000);
2024 pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1000229000);
2025 pub const PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR: Self = Self(1000231000);
2026 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: Self = Self(1000232000);
2027 pub const RENDERING_ATTACHMENT_LOCATION_INFO_KHR: Self = Self(1000232001);
2028 pub const RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: Self = Self(1000232002);
2029 pub const PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR: Self = Self(1000233000);
2030 pub const DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR: Self = Self(1000233001);
2031 pub const PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR: Self = Self(1000233002);
2032 pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: Self = Self(1000234000);
2033 pub const PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: Self = Self(1000235000);
2034 pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1000237000);
2035 pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1000238000);
2036 pub const MEMORY_PRIORITY_ALLOCATE_INFO_EXT: Self = Self(1000238001);
2037 pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1000239000);
2038 pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: Self =
2039 Self(1000240000);
2040 pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self = Self(1000241000);
2041 pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: Self = Self(1000241001);
2042 pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: Self = Self(1000241002);
2043 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1000244000);
2044 pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self = Self(1000244000);
2045 pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = Self(1000244001);
2046 pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1000244002);
2047 pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self(1000245000);
2048 pub const IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: Self = Self(1000246000);
2049 pub const VALIDATION_FEATURES_EXT: Self = Self(1000247000);
2050 pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1000248000);
2051 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1000249000);
2052 pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1000249001);
2053 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1000249002);
2054 pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self(1000250000);
2055 pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: Self = Self(1000250001);
2056 pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: Self = Self(1000250002);
2057 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self(1000251000);
2058 pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1000252000);
2059 pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: Self = Self(1000253000);
2060 pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: Self = Self(1000254000);
2061 pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: Self = Self(1000254001);
2062 pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: Self = Self(1000254002);
2063 #[cfg(feature = "platform-win32")]
2064 pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1000255000);
2065 #[cfg(feature = "platform-win32")]
2066 pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1000255002);
2067 #[cfg(feature = "platform-win32")]
2068 pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: Self = Self(1000255001);
2069 pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1000256000);
2070 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self = Self(1000257000);
2071 pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = Self(1000244001);
2072 pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self = Self(1000257002);
2073 pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self = Self(1000257003);
2074 pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self = Self(1000257004);
2075 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1000259000);
2076 pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: Self = Self(1000259001);
2077 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1000259002);
2078 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: Self = Self(1000260000);
2079 pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: Self = Self(1000261000);
2080 pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1000265000);
2081 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1000267000);
2082 pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self = Self(1000269000);
2083 pub const PIPELINE_INFO_KHR: Self = Self(1000269001);
2084 pub const PIPELINE_EXECUTABLE_PROPERTIES_KHR: Self = Self(1000269002);
2085 pub const PIPELINE_EXECUTABLE_INFO_KHR: Self = Self(1000269003);
2086 pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1000269004);
2087 pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1000269005);
2088 pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: Self = Self(1000270000);
2089 pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: Self = Self(1000270001);
2090 pub const MEMORY_TO_IMAGE_COPY_EXT: Self = Self(1000270002);
2091 pub const IMAGE_TO_MEMORY_COPY_EXT: Self = Self(1000270003);
2092 pub const COPY_IMAGE_TO_MEMORY_INFO_EXT: Self = Self(1000270004);
2093 pub const COPY_MEMORY_TO_IMAGE_INFO_EXT: Self = Self(1000270005);
2094 pub const HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT: Self = Self(1000270006);
2095 pub const COPY_IMAGE_TO_IMAGE_INFO_EXT: Self = Self(1000270007);
2096 pub const SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: Self = Self(1000270008);
2097 pub const HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: Self = Self(1000270009);
2098 pub const MEMORY_MAP_INFO_KHR: Self = Self(1000271000);
2099 pub const MEMORY_UNMAP_INFO_KHR: Self = Self(1000271001);
2100 pub const PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: Self = Self(1000272000);
2101 pub const PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: Self = Self(1000272001);
2102 pub const MEMORY_MAP_PLACED_INFO_EXT: Self = Self(1000272002);
2103 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1000273000);
2104 pub const SURFACE_PRESENT_MODE_EXT: Self = Self(1000274000);
2105 pub const SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: Self = Self(1000274001);
2106 pub const SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: Self = Self(1000274002);
2107 pub const PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: Self = Self(1000275000);
2108 pub const SWAPCHAIN_PRESENT_FENCE_INFO_EXT: Self = Self(1000275001);
2109 pub const SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: Self = Self(1000275002);
2110 pub const SWAPCHAIN_PRESENT_MODE_INFO_EXT: Self = Self(1000275003);
2111 pub const SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: Self = Self(1000275004);
2112 pub const RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: Self = Self(1000275005);
2113 pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: Self =
2114 Self(1000276000);
2115 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1000277000);
2116 pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1000277001);
2117 pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1000277002);
2118 pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1000277003);
2119 pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: Self = Self(1000277004);
2120 pub const GENERATED_COMMANDS_INFO_NV: Self = Self(1000277005);
2121 pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1000277006);
2122 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: Self = Self(1000277007);
2123 pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: Self = Self(1000278000);
2124 pub const COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: Self = Self(1000278001);
2125 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: Self = Self(1000280000);
2126 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: Self = Self(1000280001);
2127 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: Self = Self(1000281000);
2128 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self = Self(1000281001);
2129 pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self = Self(1000282000);
2130 pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1000282001);
2131 pub const PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: Self = Self(1000283000);
2132 pub const DEPTH_BIAS_INFO_EXT: Self = Self(1000283001);
2133 pub const DEPTH_BIAS_REPRESENTATION_INFO_EXT: Self = Self(1000283002);
2134 pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: Self = Self(1000284000);
2135 pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: Self = Self(1000284001);
2136 pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: Self = Self(1000284002);
2137 pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: Self = Self(1000286000);
2138 pub const PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: Self = Self(1000286001);
2139 pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: Self = Self(1000287000);
2140 pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: Self = Self(1000287001);
2141 pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: Self = Self(1000287002);
2142 pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: Self = Self(1000288000);
2143 pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1000290000);
2144 pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: Self = Self(1000292000);
2145 pub const SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: Self = Self(1000292001);
2146 pub const SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: Self = Self(1000292002);
2147 pub const PRESENT_ID_KHR: Self = Self(1000294000);
2148 pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1000294001);
2149 pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: Self = Self(1000295000);
2150 pub const DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: Self = Self(1000295001);
2151 pub const PRIVATE_DATA_SLOT_CREATE_INFO_EXT: Self = Self(1000295002);
2152 pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self = Self(1000297000);
2153 pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1000299000);
2154 pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1000299001);
2155 pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1000299002);
2156 pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1000299003);
2157 pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1000299004);
2158 pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: Self = Self(1000299005);
2159 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: Self = Self(1000299006);
2160 pub const VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: Self = Self(1000299007);
2161 pub const VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: Self = Self(1000299008);
2162 pub const VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: Self = Self(1000299009);
2163 pub const VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: Self = Self(1000299010);
2164 pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1000300000);
2165 pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: Self = Self(1000300001);
2166 pub const PERF_HINT_INFO_QCOM: Self = Self(1000302000);
2167 pub const PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM: Self = Self(1000302001);
2168 pub const PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM: Self = Self(1000302002);
2169 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: Self = Self(1000303000);
2170 pub const PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: Self = Self(1000304000);
2171 pub const PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: Self = Self(1000304001);
2172 pub const PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: Self = Self(1000305000);
2173 pub const PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: Self = Self(1000305001);
2174 #[cfg(feature = "provisional")]
2175 pub const CUDA_MODULE_CREATE_INFO_NV: Self = Self(1000307000);
2176 #[cfg(feature = "provisional")]
2177 pub const CUDA_FUNCTION_CREATE_INFO_NV: Self = Self(1000307001);
2178 #[cfg(feature = "provisional")]
2179 pub const CUDA_LAUNCH_INFO_NV: Self = Self(1000307002);
2180 #[cfg(feature = "provisional")]
2181 pub const PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: Self = Self(1000307003);
2182 #[cfg(feature = "provisional")]
2183 pub const PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: Self = Self(1000307004);
2184 pub const PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: Self = Self(1000309000);
2185 pub const PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: Self = Self(1000309001);
2186 pub const RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: Self = Self(1000309002);
2187 pub const PER_TILE_BEGIN_INFO_QCOM: Self = Self(1000309003);
2188 pub const PER_TILE_END_INFO_QCOM: Self = Self(1000309004);
2189 pub const DISPATCH_TILE_INFO_QCOM: Self = Self(1000309005);
2190 pub const QUERY_LOW_LATENCY_SUPPORT_NV: Self = Self(1000310000);
2191 #[cfg(feature = "platform-metal")]
2192 pub const EXPORT_METAL_OBJECT_CREATE_INFO_EXT: Self = Self(1000311000);
2193 #[cfg(feature = "platform-metal")]
2194 pub const EXPORT_METAL_OBJECTS_INFO_EXT: Self = Self(1000311001);
2195 #[cfg(feature = "platform-metal")]
2196 pub const EXPORT_METAL_DEVICE_INFO_EXT: Self = Self(1000311002);
2197 #[cfg(feature = "platform-metal")]
2198 pub const EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: Self = Self(1000311003);
2199 #[cfg(feature = "platform-metal")]
2200 pub const EXPORT_METAL_BUFFER_INFO_EXT: Self = Self(1000311004);
2201 #[cfg(feature = "platform-metal")]
2202 pub const IMPORT_METAL_BUFFER_INFO_EXT: Self = Self(1000311005);
2203 #[cfg(feature = "platform-metal")]
2204 pub const EXPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1000311006);
2205 #[cfg(feature = "platform-metal")]
2206 pub const IMPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1000311007);
2207 #[cfg(feature = "platform-metal")]
2208 pub const EXPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1000311008);
2209 #[cfg(feature = "platform-metal")]
2210 pub const IMPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1000311009);
2211 #[cfg(feature = "platform-metal")]
2212 pub const EXPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1000311010);
2213 #[cfg(feature = "platform-metal")]
2214 pub const IMPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1000311011);
2215 pub const MEMORY_BARRIER_2_KHR: Self = Self(1000314000);
2216 pub const BUFFER_MEMORY_BARRIER_2_KHR: Self = Self(1000314001);
2217 pub const IMAGE_MEMORY_BARRIER_2_KHR: Self = Self(1000314002);
2218 pub const DEPENDENCY_INFO_KHR: Self = Self(1000314003);
2219 pub const SUBMIT_INFO_2_KHR: Self = Self(1000314004);
2220 pub const SEMAPHORE_SUBMIT_INFO_KHR: Self = Self(1000314005);
2221 pub const COMMAND_BUFFER_SUBMIT_INFO_KHR: Self = Self(1000314006);
2222 pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: Self = Self(1000314007);
2223 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: Self = Self(1000316000);
2224 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1000316001);
2225 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: Self = Self(1000316002);
2226 pub const DESCRIPTOR_ADDRESS_INFO_EXT: Self = Self(1000316003);
2227 pub const DESCRIPTOR_GET_INFO_EXT: Self = Self(1000316004);
2228 pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1000316005);
2229 pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1000316006);
2230 pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1000316007);
2231 pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1000316008);
2232 pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: Self = Self(1000316010);
2233 pub const DESCRIPTOR_BUFFER_BINDING_INFO_EXT: Self = Self(1000316011);
2234 pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: Self = Self(1000316012);
2235 pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1000316009);
2236 pub const DEVICE_MEMORY_COPY_KHR: Self = Self(1000318000);
2237 pub const COPY_DEVICE_MEMORY_INFO_KHR: Self = Self(1000318001);
2238 pub const DEVICE_MEMORY_IMAGE_COPY_KHR: Self = Self(1000318002);
2239 pub const COPY_DEVICE_MEMORY_IMAGE_INFO_KHR: Self = Self(1000318003);
2240 pub const MEMORY_RANGE_BARRIERS_INFO_KHR: Self = Self(1000318004);
2241 pub const MEMORY_RANGE_BARRIER_KHR: Self = Self(1000318005);
2242 pub const PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR: Self = Self(1000318006);
2243 pub const BIND_INDEX_BUFFER_3_INFO_KHR: Self = Self(1000318007);
2244 pub const BIND_VERTEX_BUFFER_3_INFO_KHR: Self = Self(1000318008);
2245 pub const DRAW_INDIRECT_2_INFO_KHR: Self = Self(1000318009);
2246 pub const DRAW_INDIRECT_COUNT_2_INFO_KHR: Self = Self(1000318010);
2247 pub const DISPATCH_INDIRECT_2_INFO_KHR: Self = Self(1000318011);
2248 pub const CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT: Self = Self(1000318012);
2249 pub const BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT: Self = Self(1000318013);
2250 pub const MEMORY_MARKER_INFO_AMD: Self = Self(1000318014);
2251 pub const ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR: Self = Self(1000318015);
2252 pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: Self = Self(1000320000);
2253 pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: Self = Self(1000320001);
2254 pub const GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: Self = Self(1000320002);
2255 pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: Self =
2256 Self(1000321000);
2257 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: Self = Self(1000203000);
2258 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: Self = Self(1000322000);
2259 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: Self =
2260 Self(1000323000);
2261 pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: Self = Self(1000325000);
2262 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: Self = Self(1000326000);
2263 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: Self = Self(1000326001);
2264 pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: Self = Self(1000326002);
2265 pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: Self = Self(1000327000);
2266 pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: Self = Self(1000327001);
2267 pub const ACCELERATION_STRUCTURE_MOTION_INFO_NV: Self = Self(1000327002);
2268 pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: Self = Self(1000328000);
2269 pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: Self = Self(1000328001);
2270 pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: Self = Self(1000330000);
2271 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self(1000332000);
2272 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: Self = Self(1000332001);
2273 pub const COPY_COMMAND_TRANSFORM_INFO_QCOM: Self = Self(1000333000);
2274 pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: Self = Self(1000335000);
2275 pub const PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: Self = Self(1000336000);
2276 pub const COPY_BUFFER_INFO_2_KHR: Self = Self(1000337000);
2277 pub const COPY_IMAGE_INFO_2_KHR: Self = Self(1000337001);
2278 pub const COPY_BUFFER_TO_IMAGE_INFO_2_KHR: Self = Self(1000337002);
2279 pub const COPY_IMAGE_TO_BUFFER_INFO_2_KHR: Self = Self(1000337003);
2280 pub const BLIT_IMAGE_INFO_2_KHR: Self = Self(1000337004);
2281 pub const RESOLVE_IMAGE_INFO_2_KHR: Self = Self(1000337005);
2282 pub const BUFFER_COPY_2_KHR: Self = Self(1000337006);
2283 pub const IMAGE_COPY_2_KHR: Self = Self(1000337007);
2284 pub const IMAGE_BLIT_2_KHR: Self = Self(1000337008);
2285 pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self(1000337009);
2286 pub const IMAGE_RESOLVE_2_KHR: Self = Self(1000337010);
2287 pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self(1000338000);
2288 pub const IMAGE_COMPRESSION_CONTROL_EXT: Self = Self(1000338001);
2289 pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self(1000338002);
2290 pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self(1000338003);
2291 pub const IMAGE_COMPRESSION_PROPERTIES_EXT: Self = Self(1000338004);
2292 pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: Self = Self(1000339000);
2293 pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1000340000);
2294 pub const PHYSICAL_DEVICE_FAULT_FEATURES_EXT: Self = Self(1000341000);
2295 pub const DEVICE_FAULT_COUNTS_EXT: Self = Self(1000341001);
2296 pub const DEVICE_FAULT_INFO_EXT: Self = Self(1000341002);
2297 pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: Self =
2298 Self(1000342000);
2299 pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: Self = Self(1000344000);
2300 #[cfg(feature = "platform-directfb")]
2301 pub const DIRECTFB_SURFACE_CREATE_INFO_EXT: Self = Self(1000346000);
2302 pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self = Self(1000351000);
2303 pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self = Self(1000351002);
2304 pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1000352000);
2305 pub const VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: Self = Self(1000352001);
2306 pub const VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: Self = Self(1000352002);
2307 pub const PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: Self = Self(1000353000);
2308 pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: Self = Self(1000354000);
2309 pub const DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: Self = Self(1000354001);
2310 pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: Self = Self(1000355000);
2311 pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: Self = Self(1000355001);
2312 pub const PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: Self = Self(1000356000);
2313 pub const FORMAT_PROPERTIES_3_KHR: Self = Self(1000360000);
2314 pub const PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: Self = Self(1000361000);
2315 #[cfg(feature = "platform-fuchsia")]
2316 pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1000364000);
2317 #[cfg(feature = "platform-fuchsia")]
2318 pub const MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: Self = Self(1000364001);
2319 #[cfg(feature = "platform-fuchsia")]
2320 pub const MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1000364002);
2321 #[cfg(feature = "platform-fuchsia")]
2322 pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1000365000);
2323 #[cfg(feature = "platform-fuchsia")]
2324 pub const SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1000365001);
2325 #[cfg(feature = "platform-fuchsia")]
2326 pub const BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: Self = Self(1000366000);
2327 #[cfg(feature = "platform-fuchsia")]
2328 pub const IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: Self = Self(1000366001);
2329 #[cfg(feature = "platform-fuchsia")]
2330 pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: Self = Self(1000366002);
2331 #[cfg(feature = "platform-fuchsia")]
2332 pub const BUFFER_COLLECTION_PROPERTIES_FUCHSIA: Self = Self(1000366003);
2333 #[cfg(feature = "platform-fuchsia")]
2334 pub const BUFFER_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1000366004);
2335 #[cfg(feature = "platform-fuchsia")]
2336 pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: Self = Self(1000366005);
2337 #[cfg(feature = "platform-fuchsia")]
2338 pub const IMAGE_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1000366006);
2339 #[cfg(feature = "platform-fuchsia")]
2340 pub const IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1000366007);
2341 #[cfg(feature = "platform-fuchsia")]
2342 pub const SYSMEM_COLOR_SPACE_FUCHSIA: Self = Self(1000366008);
2343 #[cfg(feature = "platform-fuchsia")]
2344 pub const BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1000366009);
2345 pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: Self = Self(1000369000);
2346 pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: Self = Self(1000369001);
2347 pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: Self = Self(1000369002);
2348 pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1000370000);
2349 pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1000371000);
2350 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: Self = Self(1000371001);
2351 pub const PIPELINE_PROPERTIES_IDENTIFIER_EXT: Self = Self(1000372000);
2352 pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: Self = Self(1000372001);
2353 pub const PIPELINE_INFO_EXT: Self = Self(1000269001);
2354 pub const PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: Self = Self(1000375000);
2355 pub const FRAME_BOUNDARY_EXT: Self = Self(1000375001);
2356 pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: Self =
2357 Self(1000376000);
2358 pub const SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: Self = Self(1000376001);
2359 pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: Self = Self(1000376002);
2360 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self(1000377000);
2361 #[cfg(feature = "platform-screen")]
2362 pub const SCREEN_SURFACE_CREATE_INFO_QNX: Self = Self(1000378000);
2363 pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: Self = Self(1000381000);
2364 pub const PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: Self = Self(1000381001);
2365 pub const PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: Self = Self(1000382000);
2366 pub const PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: Self = Self(1000386000);
2367 pub const PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: Self = Self(1000387000);
2368 pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: Self = Self(1000388000);
2369 pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: Self = Self(1000388001);
2370 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: Self = Self(1000390000);
2371 pub const VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: Self = Self(1000390001);
2372 pub const VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: Self = Self(1000390002);
2373 pub const VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: Self = Self(1000390003);
2374 pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: Self = Self(1000391000);
2375 pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: Self = Self(1000391001);
2376 pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: Self = Self(1000392000);
2377 pub const PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: Self = Self(1000392001);
2378 pub const PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: Self = Self(1000393000);
2379 pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: Self = Self(1000395000);
2380 pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: Self = Self(1000395001);
2381 pub const MICROMAP_BUILD_INFO_EXT: Self = Self(1000396000);
2382 pub const MICROMAP_VERSION_INFO_EXT: Self = Self(1000396001);
2383 pub const COPY_MICROMAP_INFO_EXT: Self = Self(1000396002);
2384 pub const COPY_MICROMAP_TO_MEMORY_INFO_EXT: Self = Self(1000396003);
2385 pub const COPY_MEMORY_TO_MICROMAP_INFO_EXT: Self = Self(1000396004);
2386 pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: Self = Self(1000396005);
2387 pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: Self = Self(1000396006);
2388 pub const MICROMAP_CREATE_INFO_EXT: Self = Self(1000396007);
2389 pub const MICROMAP_BUILD_SIZES_INFO_EXT: Self = Self(1000396008);
2390 pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: Self = Self(1000396009);
2391 #[cfg(feature = "provisional")]
2392 pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: Self = Self(1000397000);
2393 #[cfg(feature = "provisional")]
2394 pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: Self = Self(1000397001);
2395 #[cfg(feature = "provisional")]
2396 pub const ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: Self = Self(1000397002);
2397 pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: Self = Self(1000404000);
2398 pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: Self = Self(1000404001);
2399 pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: Self = Self(1000404002);
2400 pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: Self = Self(1000411000);
2401 pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: Self = Self(1000411001);
2402 pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: Self = Self(1000412000);
2403 pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: Self = Self(1000413000);
2404 pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: Self = Self(1000413001);
2405 pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: Self = Self(1000413002);
2406 pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: Self = Self(1000413003);
2407 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: Self = Self(1000415000);
2408 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: Self = Self(1000416000);
2409 pub const DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: Self = Self(1000417000);
2410 pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: Self = Self(1000417001);
2411 pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: Self = Self(1000417002);
2412 pub const DISPATCH_PARAMETERS_ARM: Self = Self(1000417003);
2413 pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM: Self =
2414 Self(1000417004);
2415 pub const PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: Self = Self(1000418000);
2416 pub const IMAGE_VIEW_SLICED_CREATE_INFO_EXT: Self = Self(1000418001);
2417 pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: Self = Self(1000420000);
2418 pub const DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: Self = Self(1000420001);
2419 pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: Self = Self(1000420002);
2420 pub const PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: Self = Self(1000421000);
2421 pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: Self = Self(1000422000);
2422 pub const PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: Self = Self(1000424000);
2423 pub const PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: Self = Self(1000424001);
2424 pub const RENDER_PASS_STRIPE_BEGIN_INFO_ARM: Self = Self(1000424002);
2425 pub const RENDER_PASS_STRIPE_INFO_ARM: Self = Self(1000424003);
2426 pub const RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: Self = Self(1000424004);
2427 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: Self = Self(1000425000);
2428 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: Self = Self(1000425001);
2429 pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: Self = Self(1000425002);
2430 pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: Self = Self(1000426000);
2431 pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: Self = Self(1000426001);
2432 pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: Self = Self(1000427000);
2433 pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: Self = Self(1000427001);
2434 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: Self = Self(1000428000);
2435 pub const COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: Self = Self(1000428001);
2436 pub const PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: Self = Self(1000428002);
2437 pub const PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: Self = Self(1000429008);
2438 pub const ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: Self = Self(1000429009);
2439 pub const ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: Self = Self(1000429010);
2440 pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: Self = Self(1000430000);
2441 pub const PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: Self = Self(1000434000);
2442 pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: Self =
2443 Self(1000437000);
2444 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: Self = Self(1000440000);
2445 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: Self = Self(1000440001);
2446 pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: Self = Self(1000440002);
2447 pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: Self = Self(1000451000);
2448 pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: Self = Self(1000451001);
2449 #[cfg(feature = "platform-ohos")]
2450 pub const NATIVE_BUFFER_USAGE_OHOS: Self = Self(1000452000);
2451 #[cfg(feature = "platform-ohos")]
2452 pub const NATIVE_BUFFER_PROPERTIES_OHOS: Self = Self(1000452001);
2453 #[cfg(feature = "platform-ohos")]
2454 pub const NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: Self = Self(1000452002);
2455 #[cfg(feature = "platform-ohos")]
2456 pub const IMPORT_NATIVE_BUFFER_INFO_OHOS: Self = Self(1000452003);
2457 #[cfg(feature = "platform-ohos")]
2458 pub const MEMORY_GET_NATIVE_BUFFER_INFO_OHOS: Self = Self(1000452004);
2459 #[cfg(feature = "platform-ohos")]
2460 pub const EXTERNAL_FORMAT_OHOS: Self = Self(1000452005);
2461 pub const EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: Self = Self(1000453000);
2462 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: Self = Self(1000455000);
2463 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: Self = Self(1000455001);
2464 pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: Self = Self(1000458000);
2465 pub const RENDER_PASS_CREATION_CONTROL_EXT: Self = Self(1000458001);
2466 pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1000458002);
2467 pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: Self = Self(1000458003);
2468 pub const DIRECT_DRIVER_LOADING_INFO_LUNARG: Self = Self(1000459000);
2469 pub const DIRECT_DRIVER_LOADING_LIST_LUNARG: Self = Self(1000459001);
2470 pub const TENSOR_CREATE_INFO_ARM: Self = Self(1000460000);
2471 pub const TENSOR_VIEW_CREATE_INFO_ARM: Self = Self(1000460001);
2472 pub const BIND_TENSOR_MEMORY_INFO_ARM: Self = Self(1000460002);
2473 pub const WRITE_DESCRIPTOR_SET_TENSOR_ARM: Self = Self(1000460003);
2474 pub const PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: Self = Self(1000460004);
2475 pub const TENSOR_FORMAT_PROPERTIES_ARM: Self = Self(1000460005);
2476 pub const TENSOR_DESCRIPTION_ARM: Self = Self(1000460006);
2477 pub const TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: Self = Self(1000460007);
2478 pub const TENSOR_MEMORY_BARRIER_ARM: Self = Self(1000460008);
2479 pub const PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: Self = Self(1000460009);
2480 pub const DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: Self = Self(1000460010);
2481 pub const COPY_TENSOR_INFO_ARM: Self = Self(1000460011);
2482 pub const TENSOR_COPY_ARM: Self = Self(1000460012);
2483 pub const TENSOR_DEPENDENCY_INFO_ARM: Self = Self(1000460013);
2484 pub const MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: Self = Self(1000460014);
2485 pub const PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: Self = Self(1000460015);
2486 pub const EXTERNAL_TENSOR_PROPERTIES_ARM: Self = Self(1000460016);
2487 pub const EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: Self = Self(1000460017);
2488 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: Self = Self(1000460018);
2489 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: Self = Self(1000460019);
2490 pub const DESCRIPTOR_GET_TENSOR_INFO_ARM: Self = Self(1000460020);
2491 pub const TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: Self = Self(1000460021);
2492 pub const TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: Self = Self(1000460022);
2493 pub const FRAME_BOUNDARY_TENSORS_ARM: Self = Self(1000460023);
2494 pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: Self = Self(1000462000);
2495 pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: Self = Self(1000462001);
2496 pub const PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: Self = Self(1000462002);
2497 pub const SHADER_MODULE_IDENTIFIER_EXT: Self = Self(1000462003);
2498 pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: Self =
2499 Self(1000342000);
2500 pub const PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: Self = Self(1000464000);
2501 pub const PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: Self = Self(1000464001);
2502 pub const OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: Self = Self(1000464002);
2503 pub const OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: Self = Self(1000464003);
2504 pub const OPTICAL_FLOW_SESSION_CREATE_INFO_NV: Self = Self(1000464004);
2505 pub const OPTICAL_FLOW_EXECUTE_INFO_NV: Self = Self(1000464005);
2506 pub const OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: Self = Self(1000464010);
2507 pub const PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: Self = Self(1000465000);
2508 pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: Self = Self(1000466000);
2509 #[cfg(feature = "platform-android")]
2510 pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: Self = Self(1000468000);
2511 #[cfg(feature = "platform-android")]
2512 pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: Self = Self(1000468001);
2513 #[cfg(feature = "platform-android")]
2514 pub const ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: Self = Self(1000468002);
2515 pub const PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: Self = Self(1000470000);
2516 pub const PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: Self = Self(1000470001);
2517 pub const RENDERING_AREA_INFO_KHR: Self = Self(1000470003);
2518 pub const DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: Self = Self(1000470004);
2519 pub const SUBRESOURCE_LAYOUT_2_KHR: Self = Self(1000338002);
2520 pub const IMAGE_SUBRESOURCE_2_KHR: Self = Self(1000338003);
2521 pub const PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: Self = Self(1000470005);
2522 pub const BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: Self = Self(1000470006);
2523 pub const PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: Self = Self(1000476000);
2524 pub const ANTI_LAG_DATA_AMD: Self = Self(1000476001);
2525 pub const ANTI_LAG_PRESENTATION_INFO_AMD: Self = Self(1000476002);
2526 #[cfg(feature = "provisional")]
2527 pub const PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: Self = Self(1000478000);
2528 #[cfg(feature = "provisional")]
2529 pub const ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: Self =
2530 Self(1000478001);
2531 pub const SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: Self = Self(1000479000);
2532 pub const PRESENT_ID_2_KHR: Self = Self(1000479001);
2533 pub const PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: Self = Self(1000479002);
2534 pub const SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: Self = Self(1000480000);
2535 pub const PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: Self = Self(1000480001);
2536 pub const PRESENT_WAIT_2_INFO_KHR: Self = Self(1000480002);
2537 pub const PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: Self = Self(1000481000);
2538 pub const PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: Self = Self(1000482000);
2539 pub const PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: Self = Self(1000482001);
2540 pub const SHADER_CREATE_INFO_EXT: Self = Self(1000482002);
2541 pub const SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self = Self(1000225001);
2542 pub const PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: Self = Self(1000483000);
2543 pub const PIPELINE_BINARY_CREATE_INFO_KHR: Self = Self(1000483001);
2544 pub const PIPELINE_BINARY_INFO_KHR: Self = Self(1000483002);
2545 pub const PIPELINE_BINARY_KEY_KHR: Self = Self(1000483003);
2546 pub const PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: Self = Self(1000483004);
2547 pub const RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: Self = Self(1000483005);
2548 pub const PIPELINE_BINARY_DATA_INFO_KHR: Self = Self(1000483006);
2549 pub const PIPELINE_CREATE_INFO_KHR: Self = Self(1000483007);
2550 pub const DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: Self = Self(1000483008);
2551 pub const PIPELINE_BINARY_HANDLES_INFO_KHR: Self = Self(1000483009);
2552 pub const PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: Self = Self(1000484000);
2553 pub const TILE_PROPERTIES_QCOM: Self = Self(1000484001);
2554 pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: Self = Self(1000485000);
2555 pub const AMIGO_PROFILING_SUBMIT_INFO_SEC: Self = Self(1000485001);
2556 pub const SURFACE_PRESENT_MODE_KHR: Self = Self(1000274000);
2557 pub const SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: Self = Self(1000274001);
2558 pub const SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: Self = Self(1000274002);
2559 pub const PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: Self = Self(1000275000);
2560 pub const SWAPCHAIN_PRESENT_FENCE_INFO_KHR: Self = Self(1000275001);
2561 pub const SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: Self = Self(1000275002);
2562 pub const SWAPCHAIN_PRESENT_MODE_INFO_KHR: Self = Self(1000275003);
2563 pub const SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: Self = Self(1000275004);
2564 pub const RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: Self = Self(1000275005);
2565 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: Self = Self(1000488000);
2566 pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: Self = Self(1000490000);
2567 pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: Self = Self(1000490001);
2568 pub const PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: Self = Self(1000491000);
2569 pub const PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: Self = Self(1000491001);
2570 pub const COOPERATIVE_VECTOR_PROPERTIES_NV: Self = Self(1000491002);
2571 pub const CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: Self = Self(1000491004);
2572 pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: Self = Self(1000492000);
2573 pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: Self = Self(1000492001);
2574 pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: Self = Self(1000351000);
2575 pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: Self = Self(1000351002);
2576 pub const PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: Self = Self(1000495000);
2577 pub const PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: Self = Self(1000495001);
2578 pub const LAYER_SETTINGS_CREATE_INFO_EXT: Self = Self(1000496000);
2579 pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: Self = Self(1000497000);
2580 pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: Self = Self(1000497001);
2581 pub const PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: Self = Self(1000498000);
2582 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: Self =
2583 Self(1000499000);
2584 pub const PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: Self = Self(1000504000);
2585 pub const LATENCY_SLEEP_MODE_INFO_NV: Self = Self(1000505000);
2586 pub const LATENCY_SLEEP_INFO_NV: Self = Self(1000505001);
2587 pub const SET_LATENCY_MARKER_INFO_NV: Self = Self(1000505002);
2588 pub const GET_LATENCY_MARKER_INFO_NV: Self = Self(1000505003);
2589 pub const LATENCY_TIMINGS_FRAME_REPORT_NV: Self = Self(1000505004);
2590 pub const LATENCY_SUBMISSION_PRESENT_ID_NV: Self = Self(1000505005);
2591 pub const OUT_OF_BAND_QUEUE_TYPE_INFO_NV: Self = Self(1000505006);
2592 pub const SWAPCHAIN_LATENCY_CREATE_INFO_NV: Self = Self(1000505007);
2593 pub const LATENCY_SURFACE_CAPABILITIES_NV: Self = Self(1000505008);
2594 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: Self = Self(1000506000);
2595 pub const COOPERATIVE_MATRIX_PROPERTIES_KHR: Self = Self(1000506001);
2596 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: Self = Self(1000506002);
2597 pub const DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: Self = Self(1000507000);
2598 pub const DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: Self = Self(1000507001);
2599 pub const DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: Self = Self(1000507002);
2600 pub const DATA_GRAPH_PIPELINE_CONSTANT_ARM: Self = Self(1000507003);
2601 pub const DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: Self = Self(1000507004);
2602 pub const BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: Self = Self(1000507005);
2603 pub const PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: Self = Self(1000507006);
2604 pub const DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: Self = Self(1000507007);
2605 pub const DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: Self = Self(1000507008);
2606 pub const DATA_GRAPH_PIPELINE_INFO_ARM: Self = Self(1000507009);
2607 pub const DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: Self = Self(1000507010);
2608 pub const DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: Self = Self(1000507011);
2609 pub const DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: Self = Self(1000507012);
2610 pub const DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: Self = Self(1000507013);
2611 pub const DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: Self = Self(1000507014);
2612 pub const DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: Self = Self(1000507016);
2613 pub const QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: Self = Self(1000507017);
2614 pub const QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: Self = Self(1000507018);
2615 pub const PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: Self =
2616 Self(1000507019);
2617 pub const DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: Self =
2618 Self(1000507015);
2619 pub const QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM: Self = Self(1000508000);
2620 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: Self = Self(1000510000);
2621 pub const MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: Self = Self(1000510001);
2622 pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: Self = Self(1000201000);
2623 pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: Self = Self(1000511000);
2624 pub const VIDEO_DECODE_AV1_CAPABILITIES_KHR: Self = Self(1000512000);
2625 pub const VIDEO_DECODE_AV1_PICTURE_INFO_KHR: Self = Self(1000512001);
2626 pub const VIDEO_DECODE_AV1_PROFILE_INFO_KHR: Self = Self(1000512003);
2627 pub const VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1000512004);
2628 pub const VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: Self = Self(1000512005);
2629 pub const VIDEO_ENCODE_AV1_CAPABILITIES_KHR: Self = Self(1000513000);
2630 pub const VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1000513001);
2631 pub const VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: Self = Self(1000513002);
2632 pub const VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: Self = Self(1000513003);
2633 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: Self = Self(1000513004);
2634 pub const VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: Self = Self(1000513005);
2635 pub const VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: Self = Self(1000513006);
2636 pub const VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1000513007);
2637 pub const VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: Self = Self(1000513008);
2638 pub const VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: Self = Self(1000513009);
2639 pub const VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: Self = Self(1000513010);
2640 pub const PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: Self = Self(1000514000);
2641 pub const VIDEO_DECODE_VP9_CAPABILITIES_KHR: Self = Self(1000514001);
2642 pub const VIDEO_DECODE_VP9_PICTURE_INFO_KHR: Self = Self(1000514002);
2643 pub const VIDEO_DECODE_VP9_PROFILE_INFO_KHR: Self = Self(1000514003);
2644 pub const PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: Self = Self(1000515000);
2645 pub const VIDEO_INLINE_QUERY_INFO_KHR: Self = Self(1000515001);
2646 pub const PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: Self = Self(1000516000);
2647 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: Self = Self(1000518000);
2648 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: Self = Self(1000518001);
2649 pub const SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: Self = Self(1000518002);
2650 pub const SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: Self = Self(1000519000);
2651 pub const PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: Self = Self(1000519001);
2652 pub const BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: Self = Self(1000519002);
2653 pub const PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: Self = Self(1000520000);
2654 pub const SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: Self = Self(1000520001);
2655 pub const PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: Self = Self(1000521000);
2656 pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: Self =
2657 Self(1000524000);
2658 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: Self = Self(1000525000);
2659 pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: Self = Self(1000190001);
2660 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: Self = Self(1000190002);
2661 pub const PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: Self = Self(1000527000);
2662 pub const ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: Self = Self(1000527001);
2663 pub const PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: Self = Self(1000528000);
2664 #[cfg(feature = "platform-screen")]
2665 pub const SCREEN_BUFFER_PROPERTIES_QNX: Self = Self(1000529000);
2666 #[cfg(feature = "platform-screen")]
2667 pub const SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: Self = Self(1000529001);
2668 #[cfg(feature = "platform-screen")]
2669 pub const IMPORT_SCREEN_BUFFER_INFO_QNX: Self = Self(1000529002);
2670 #[cfg(feature = "platform-screen")]
2671 pub const EXTERNAL_FORMAT_QNX: Self = Self(1000529003);
2672 #[cfg(feature = "platform-screen")]
2673 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: Self = Self(1000529004);
2674 pub const PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: Self = Self(1000530000);
2675 pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: Self = Self(1000265000);
2676 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: Self = Self(1000259000);
2677 pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: Self = Self(1000259001);
2678 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: Self = Self(1000259002);
2679 pub const CALIBRATED_TIMESTAMP_INFO_KHR: Self = Self(1000184000);
2680 pub const PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: Self = Self(1000544000);
2681 pub const PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: Self = Self(1000545000);
2682 pub const PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: Self = Self(1000545001);
2683 pub const BIND_MEMORY_STATUS_KHR: Self = Self(1000545002);
2684 pub const BIND_DESCRIPTOR_SETS_INFO_KHR: Self = Self(1000545003);
2685 pub const PUSH_CONSTANTS_INFO_KHR: Self = Self(1000545004);
2686 pub const PUSH_DESCRIPTOR_SET_INFO_KHR: Self = Self(1000545005);
2687 pub const PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: Self = Self(1000545006);
2688 pub const SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: Self = Self(1000545007);
2689 pub const BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: Self = Self(1000545008);
2690 pub const PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: Self = Self(1000546000);
2691 pub const PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: Self = Self(1000547000);
2692 pub const PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: Self = Self(1000547001);
2693 pub const TILE_MEMORY_REQUIREMENTS_QCOM: Self = Self(1000547002);
2694 pub const TILE_MEMORY_BIND_INFO_QCOM: Self = Self(1000547003);
2695 pub const TILE_MEMORY_SIZE_INFO_QCOM: Self = Self(1000547004);
2696 pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: Self = Self(1000549000);
2697 pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: Self = Self(1000426001);
2698 pub const COPY_MEMORY_INDIRECT_INFO_KHR: Self = Self(1000549002);
2699 pub const COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: Self = Self(1000549003);
2700 pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: Self = Self(1000427000);
2701 pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: Self = Self(1000427001);
2702 pub const DECOMPRESS_MEMORY_INFO_EXT: Self = Self(1000550002);
2703 pub const DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: Self = Self(1000551000);
2704 pub const DISPLAY_MODE_STEREO_PROPERTIES_NV: Self = Self(1000551001);
2705 pub const VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: Self = Self(1000552000);
2706 pub const VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: Self = Self(1000552001);
2707 pub const VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: Self = Self(1000552002);
2708 pub const VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: Self = Self(1000552003);
2709 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: Self = Self(1000552004);
2710 pub const VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: Self = Self(1000553000);
2711 pub const VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: Self = Self(1000553001);
2712 pub const VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: Self = Self(1000553002);
2713 pub const VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: Self =
2714 Self(1000553005);
2715 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: Self = Self(1000553009);
2716 pub const VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: Self = Self(1000553003);
2717 pub const VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: Self = Self(1000553004);
2718 pub const VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: Self = Self(1000553006);
2719 pub const VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: Self = Self(1000553007);
2720 pub const VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: Self = Self(1000553008);
2721 pub const PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: Self = Self(1000555000);
2722 pub const EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: Self = Self(1000556000);
2723 pub const EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: Self = Self(1000556001);
2724 pub const EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: Self = Self(1000556002);
2725 pub const PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: Self = Self(1000556003);
2726 pub const PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: Self =
2727 Self(1000558000);
2728 pub const PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: Self = Self(1000559000);
2729 pub const PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: Self = Self(1000562000);
2730 pub const PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: Self = Self(1000562001);
2731 pub const PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: Self = Self(1000562002);
2732 pub const PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: Self = Self(1000562003);
2733 pub const PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: Self = Self(1000562004);
2734 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: Self = Self(1000563000);
2735 pub const PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: Self = Self(1000564000);
2736 pub const TENSOR_EXPLICIT_TILING_FORMAT_PROPERTIES_ARM: Self = Self(1000565000);
2737 pub const TENSOR_ROLLING_BACKING_CREATE_INFO_ARM: Self = Self(1000565001);
2738 pub const PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: Self = Self(1000567000);
2739 pub const PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: Self = Self(1000568000);
2740 pub const PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: Self = Self(1000569000);
2741 pub const PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: Self = Self(1000569001);
2742 pub const CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: Self = Self(1000569002);
2743 pub const CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: Self = Self(1000569003);
2744 pub const CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: Self = Self(1000569004);
2745 pub const CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: Self = Self(1000569005);
2746 pub const CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: Self = Self(1000569006);
2747 pub const RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self =
2748 Self(1000569007);
2749 pub const PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: Self = Self(1000570000);
2750 pub const PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: Self =
2751 Self(1000570001);
2752 pub const WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: Self = Self(1000570002);
2753 pub const PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: Self = Self(1000570003);
2754 pub const BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1000570004);
2755 pub const PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: Self = Self(1000570005);
2756 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: Self = Self(1000572000);
2757 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: Self = Self(1000572001);
2758 pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: Self = Self(1000572002);
2759 pub const INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: Self = Self(1000572003);
2760 pub const GENERATED_COMMANDS_INFO_EXT: Self = Self(1000572004);
2761 pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: Self = Self(1000572006);
2762 pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: Self = Self(1000572007);
2763 pub const WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: Self = Self(1000572008);
2764 pub const WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: Self = Self(1000572009);
2765 pub const INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: Self = Self(1000572010);
2766 pub const INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: Self = Self(1000572011);
2767 pub const INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: Self = Self(1000572012);
2768 pub const GENERATED_COMMANDS_PIPELINE_INFO_EXT: Self = Self(1000572013);
2769 pub const GENERATED_COMMANDS_SHADER_INFO_EXT: Self = Self(1000572014);
2770 pub const PHYSICAL_DEVICE_FAULT_FEATURES_KHR: Self = Self(1000573000);
2771 pub const PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR: Self = Self(1000573001);
2772 pub const DEVICE_FAULT_INFO_KHR: Self = Self(1000573002);
2773 pub const DEVICE_FAULT_DEBUG_INFO_KHR: Self = Self(1000573003);
2774 pub const PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: Self = Self(1000574000);
2775 pub const MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: Self = Self(1000574002);
2776 pub const PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: Self = Self(1000575000);
2777 pub const PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: Self = Self(1000575001);
2778 pub const IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: Self = Self(1000575002);
2779 pub const PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: Self = Self(1000579000);
2780 pub const PUSH_CONSTANT_BANK_INFO_NV: Self = Self(1000580000);
2781 pub const PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: Self = Self(1000580001);
2782 pub const PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV: Self = Self(1000580002);
2783 pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: Self = Self(1000581000);
2784 pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: Self = Self(1000581001);
2785 pub const PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: Self = Self(1000582000);
2786 pub const PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: Self = Self(1000582001);
2787 pub const PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: Self = Self(1000584000);
2788 pub const PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: Self = Self(1000584001);
2789 pub const QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: Self = Self(1000584002);
2790 pub const PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: Self = Self(1000586000);
2791 pub const VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: Self = Self(1000586001);
2792 pub const VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: Self = Self(1000586002);
2793 pub const VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: Self = Self(1000586003);
2794 #[cfg(feature = "platform-ohos")]
2795 pub const SURFACE_CREATE_INFO_OHOS: Self = Self(1000685000);
2796 pub const PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: Self = Self(1000590000);
2797 pub const HDR_VIVID_DYNAMIC_METADATA_HUAWEI: Self = Self(1000590001);
2798 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: Self = Self(1000593000);
2799 pub const COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: Self = Self(1000593001);
2800 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: Self = Self(1000593002);
2801 pub const PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: Self = Self(1000596000);
2802 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR: Self = Self(1000598000);
2803 pub const VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR: Self = Self(1000598001);
2804 pub const QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR: Self = Self(1000598002);
2805 #[cfg(feature = "platform-metal")]
2806 pub const IMPORT_MEMORY_METAL_HANDLE_INFO_EXT: Self = Self(1000602000);
2807 #[cfg(feature = "platform-metal")]
2808 pub const MEMORY_METAL_HANDLE_PROPERTIES_EXT: Self = Self(1000602001);
2809 #[cfg(feature = "platform-metal")]
2810 pub const MEMORY_GET_METAL_HANDLE_INFO_EXT: Self = Self(1000602002);
2811 pub const PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: Self = Self(1000421000);
2812 pub const PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: Self = Self(1000605000);
2813 pub const PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: Self = Self(1000605001);
2814 pub const PERFORMANCE_COUNTER_ARM: Self = Self(1000605002);
2815 pub const PERFORMANCE_COUNTER_DESCRIPTION_ARM: Self = Self(1000605003);
2816 pub const RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: Self = Self(1000605004);
2817 pub const PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM: Self = Self(1000607000);
2818 pub const PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM: Self = Self(1000607001);
2819 pub const SHADER_INSTRUMENTATION_CREATE_INFO_ARM: Self = Self(1000607002);
2820 pub const SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM: Self = Self(1000607003);
2821 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: Self = Self(1000608000);
2822 pub const PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: Self = Self(1000609000);
2823 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: Self = Self(1000611000);
2824 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: Self = Self(1000611001);
2825 pub const PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: Self = Self(1000611002);
2826 pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: Self = Self(1000286000);
2827 pub const PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: Self = Self(1000286001);
2828 pub const SET_PRESENT_CONFIG_NV: Self = Self(1000613000);
2829 pub const PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: Self = Self(1000613001);
2830 pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT: Self = Self(1000616000);
2831 pub const SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT: Self = Self(1000616001);
2832 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: Self = Self(1000425000);
2833 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: Self = Self(1000425001);
2834 pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: Self = Self(1000425002);
2835 pub const RENDERING_END_INFO_EXT: Self = Self(1000619003);
2836 pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: Self = Self(1000620000);
2837 pub const PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: Self = Self(1000361000);
2838 pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: Self = Self(1000623000);
2839 pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: Self = Self(1000623001);
2840 pub const ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR: Self = Self(1000623002);
2841 pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR: Self = Self(1000623003);
2842 pub const PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: Self = Self(1000627000);
2843 pub const PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: Self = Self(1000628000);
2844 pub const BEGIN_CUSTOM_RESOLVE_INFO_EXT: Self = Self(1000628001);
2845 pub const CUSTOM_RESOLVE_CREATE_INFO_EXT: Self = Self(1000628002);
2846 pub const PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: Self = Self(1000629000);
2847 pub const DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: Self = Self(1000629001);
2848 pub const PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: Self = Self(1000630000);
2849 pub const PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: Self = Self(1000630001);
2850 pub const RENDERING_ATTACHMENT_FLAGS_INFO_KHR: Self = Self(1000630002);
2851 pub const RENDERING_END_INFO_KHR: Self = Self(1000619003);
2852 pub const RESOLVE_IMAGE_MODE_INFO_KHR: Self = Self(1000630004);
2853 pub const PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: Self = Self(1000631000);
2854 pub const QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM: Self = Self(1000631001);
2855 pub const DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM: Self = Self(1000631003);
2856 pub const DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM: Self = Self(1000631004);
2857 pub const DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM: Self = Self(1000631005);
2858 pub const DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM: Self = Self(1000631002);
2859 pub const DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM: Self = Self(1000631006);
2860 pub const DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM: Self = Self(1000631007);
2861 pub const DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM: Self = Self(1000631008);
2862 pub const PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: Self = Self(1000635000);
2863 pub const PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: Self = Self(1000635001);
2864 pub const PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: Self = Self(1000637000);
2865 pub const PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: Self =
2866 Self(1000642000);
2867 pub const COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: Self = Self(1000645000);
2868 pub const PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: Self = Self(1000645001);
2869 pub const PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_KHR: Self = Self(1000498000);
2870 pub const PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR: Self = Self(1000657000);
2871 pub const QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR: Self = Self(1000657001);
2872 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_MAINTENANCE_1_FEATURES_EXT: Self = Self(1000659000);
2873 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_INFO_2_EXT: Self = Self(1000659001);
2874 pub const COOPERATIVE_MATRIX_PROPERTIES_2_EXT: Self = Self(1000659002);
2875 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: Self = Self(1000662000);
2876 #[cfg(feature = "platform-ubm")]
2877 pub const UBM_SURFACE_CREATE_INFO_SEC: Self = Self(1000664000);
2878 pub const FORMAT_PROPERTIES_4_KHR: Self = Self(1000668000);
2879 pub const IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR: Self = Self(1000668001);
2880 pub const IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: Self = Self(1000668002);
2881 pub const IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR: Self = Self(1000668003);
2882 pub const PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR: Self = Self(1000668004);
2883 pub const IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR: Self = Self(1000668005);
2884 pub const SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR: Self = Self(1000668006);
2885 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_LAYOUTS_FEATURES_ARM: Self = Self(1000670000);
2886 pub const PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT: Self = Self(1000672000);
2887 pub const PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE: Self = Self(1000673000);
2888 pub const PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC: Self = Self(1000674000);
2889 pub const THROTTLE_HINT_SUBMIT_INFO_SEC: Self = Self(1000674001);
2890 pub const DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM: Self = Self(1000676000);
2891 pub const DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM: Self = Self(1000676001);
2892 pub const PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM: Self =
2893 Self(1000676002);
2894 pub const PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT: Self = Self(1000678000);
2895 pub const PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT: Self = Self(1000687000);
2896 pub const IMAGE_TILING_CONTROL_CREATE_INFO_EXT: Self = Self(1000687001);
2897 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV: Self = Self(1000689000);
2898 pub const PHYSICAL_DEVICE_PRIVATE_DATA_BASE_HANDLE_FEATURES_NV: Self = Self(1000707000);
2899 pub const PHYSICAL_DEVICE_INFO_PROPERTIES_INTEL: Self = Self(1000708000);
2900 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_FEATURES_VALVE: Self =
2901 Self(1000709000);
2902 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_PROPERTIES_VALVE: Self =
2903 Self(1000709001);
2904 pub const BUFFER_DEVICE_ADDRESS_ALIGNMENT_ALLOCATE_INFO_VALVE: Self = Self(1000709002);
2905}
2906
2907#[repr(transparent)]
2908#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
2909pub struct SubpassContents(pub i32);
2910impl SubpassContents {
2911 pub const fn from_raw(value: i32) -> Self {
2912 Self(value)
2913 }
2914
2915 pub const fn as_raw(self) -> i32 {
2916 self.0
2917 }
2918
2919 pub const fn empty() -> Self {
2920 Self(0)
2921 }
2922
2923 pub const INLINE: Self = Self(0);
2924 pub const SECONDARY_COMMAND_BUFFERS: Self = Self(1);
2925 pub const INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT: Self = Self(1000451000);
2926 pub const INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR: Self = Self(1000451000);
2927}
2928
2929#[repr(transparent)]
2930#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
2931pub struct Result(pub i32);
2932impl Result {
2933 pub const fn from_raw(value: i32) -> Self {
2934 Self(value)
2935 }
2936
2937 pub const fn as_raw(self) -> i32 {
2938 self.0
2939 }
2940
2941 pub const fn empty() -> Self {
2942 Self(0)
2943 }
2944
2945 pub const SUCCESS: Self = Self(0);
2946 pub const NOT_READY: Self = Self(1);
2947 pub const TIMEOUT: Self = Self(2);
2948 pub const EVENT_SET: Self = Self(3);
2949 pub const EVENT_RESET: Self = Self(4);
2950 pub const INCOMPLETE: Self = Self(5);
2951 pub const ERROR_OUT_OF_HOST_MEMORY: Self = Self(-1);
2952 pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Self(-2);
2953 pub const ERROR_INITIALIZATION_FAILED: Self = Self(-3);
2954 pub const ERROR_DEVICE_LOST: Self = Self(-4);
2955 pub const ERROR_MEMORY_MAP_FAILED: Self = Self(-5);
2956 pub const ERROR_LAYER_NOT_PRESENT: Self = Self(-6);
2957 pub const ERROR_EXTENSION_NOT_PRESENT: Self = Self(-7);
2958 pub const ERROR_FEATURE_NOT_PRESENT: Self = Self(-8);
2959 pub const ERROR_INCOMPATIBLE_DRIVER: Self = Self(-9);
2960 pub const ERROR_TOO_MANY_OBJECTS: Self = Self(-10);
2961 pub const ERROR_FORMAT_NOT_SUPPORTED: Self = Self(-11);
2962 pub const ERROR_FRAGMENTED_POOL: Self = Self(-12);
2963 pub const ERROR_UNKNOWN: Self = Self(-13);
2964 pub const ERROR_VALIDATION_FAILED: Self = Self(-1000011001);
2965 pub const ERROR_OUT_OF_POOL_MEMORY: Self = Self(-1000069000);
2966 pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Self(-1000072003);
2967 pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Self(-1000257000);
2968 pub const ERROR_FRAGMENTATION: Self = Self(-1000161000);
2969 pub const PIPELINE_COMPILE_REQUIRED: Self = Self(1000297000);
2970 pub const ERROR_NOT_PERMITTED: Self = Self(-1000174001);
2971 pub const ERROR_SURFACE_LOST_KHR: Self = Self(-1000000000);
2972 pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Self(-1000000001);
2973 pub const SUBOPTIMAL_KHR: Self = Self(1000001003);
2974 pub const ERROR_OUT_OF_DATE_KHR: Self = Self(-1000001004);
2975 pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Self(-1000003001);
2976 pub const ERROR_VALIDATION_FAILED_EXT: Self = Self(-1000011001);
2977 pub const ERROR_INVALID_SHADER_NV: Self = Self(-1000012000);
2978 pub const ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: Self = Self(-1000023000);
2979 pub const ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: Self = Self(-1000023001);
2980 pub const ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: Self = Self(-1000023002);
2981 pub const ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: Self = Self(-1000023003);
2982 pub const ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: Self = Self(-1000023004);
2983 pub const ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: Self = Self(-1000023005);
2984 pub const ERROR_OUT_OF_POOL_MEMORY_KHR: Self = Self(-1000069000);
2985 pub const ERROR_INVALID_EXTERNAL_HANDLE_KHR: Self = Self(-1000072003);
2986 pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1000158000);
2987 pub const ERROR_FRAGMENTATION_EXT: Self = Self(-1000161000);
2988 pub const ERROR_NOT_PERMITTED_EXT: Self = Self(-1000174001);
2989 pub const ERROR_NOT_PERMITTED_KHR: Self = Self(-1000174001);
2990 pub const ERROR_PRESENT_TIMING_QUEUE_FULL_EXT: Self = Self(-1000208000);
2991 pub const ERROR_INVALID_DEVICE_ADDRESS_EXT: Self = Self(-1000257000);
2992 #[cfg(feature = "platform-win32")]
2993 pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1000255000);
2994 pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: Self = Self(-1000257000);
2995 pub const THREAD_IDLE_KHR: Self = Self(1000268000);
2996 pub const THREAD_DONE_KHR: Self = Self(1000268001);
2997 pub const OPERATION_DEFERRED_KHR: Self = Self(1000268002);
2998 pub const OPERATION_NOT_DEFERRED_KHR: Self = Self(1000268003);
2999 pub const PIPELINE_COMPILE_REQUIRED_EXT: Self = Self(1000297000);
3000 pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self(1000297000);
3001 pub const ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: Self = Self(-1000299000);
3002 pub const ERROR_COMPRESSION_EXHAUSTED_EXT: Self = Self(-1000338000);
3003 pub const INCOMPATIBLE_SHADER_BINARY_EXT: Self = Self(1000482000);
3004 pub const ERROR_INCOMPATIBLE_SHADER_BINARY_EXT: Self = Self(1000482000);
3005 pub const PIPELINE_BINARY_MISSING_KHR: Self = Self(1000483000);
3006 pub const ERROR_NOT_ENOUGH_SPACE_KHR: Self = Self(-1000483000);
3007}
3008
3009#[repr(transparent)]
3010#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3011pub struct DynamicState(pub i32);
3012impl DynamicState {
3013 pub const fn from_raw(value: i32) -> Self {
3014 Self(value)
3015 }
3016
3017 pub const fn as_raw(self) -> i32 {
3018 self.0
3019 }
3020
3021 pub const fn empty() -> Self {
3022 Self(0)
3023 }
3024
3025 pub const VIEWPORT: Self = Self(0);
3026 pub const SCISSOR: Self = Self(1);
3027 pub const LINE_WIDTH: Self = Self(2);
3028 pub const DEPTH_BIAS: Self = Self(3);
3029 pub const BLEND_CONSTANTS: Self = Self(4);
3030 pub const DEPTH_BOUNDS: Self = Self(5);
3031 pub const STENCIL_COMPARE_MASK: Self = Self(6);
3032 pub const STENCIL_WRITE_MASK: Self = Self(7);
3033 pub const STENCIL_REFERENCE: Self = Self(8);
3034 pub const CULL_MODE: Self = Self(1000267000);
3035 pub const FRONT_FACE: Self = Self(1000267001);
3036 pub const PRIMITIVE_TOPOLOGY: Self = Self(1000267002);
3037 pub const VIEWPORT_WITH_COUNT: Self = Self(1000267003);
3038 pub const SCISSOR_WITH_COUNT: Self = Self(1000267004);
3039 pub const VERTEX_INPUT_BINDING_STRIDE: Self = Self(1000267005);
3040 pub const DEPTH_TEST_ENABLE: Self = Self(1000267006);
3041 pub const DEPTH_WRITE_ENABLE: Self = Self(1000267007);
3042 pub const DEPTH_COMPARE_OP: Self = Self(1000267008);
3043 pub const DEPTH_BOUNDS_TEST_ENABLE: Self = Self(1000267009);
3044 pub const STENCIL_TEST_ENABLE: Self = Self(1000267010);
3045 pub const STENCIL_OP: Self = Self(1000267011);
3046 pub const RASTERIZER_DISCARD_ENABLE: Self = Self(1000377001);
3047 pub const DEPTH_BIAS_ENABLE: Self = Self(1000377002);
3048 pub const PRIMITIVE_RESTART_ENABLE: Self = Self(1000377004);
3049 pub const LINE_STIPPLE: Self = Self(1000259000);
3050 pub const VIEWPORT_W_SCALING_NV: Self = Self(1000087000);
3051 pub const DISCARD_RECTANGLE_EXT: Self = Self(1000099000);
3052 pub const DISCARD_RECTANGLE_ENABLE_EXT: Self = Self(1000099001);
3053 pub const DISCARD_RECTANGLE_MODE_EXT: Self = Self(1000099002);
3054 pub const SAMPLE_LOCATIONS_EXT: Self = Self(1000143000);
3055 pub const RAY_TRACING_PIPELINE_STACK_SIZE_KHR: Self = Self(1000347000);
3056 pub const VIEWPORT_SHADING_RATE_PALETTE_NV: Self = Self(1000164004);
3057 pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1000164006);
3058 pub const EXCLUSIVE_SCISSOR_ENABLE_NV: Self = Self(1000205000);
3059 pub const EXCLUSIVE_SCISSOR_NV: Self = Self(1000205001);
3060 pub const FRAGMENT_SHADING_RATE_KHR: Self = Self(1000226000);
3061 pub const LINE_STIPPLE_EXT: Self = Self(1000259000);
3062 pub const CULL_MODE_EXT: Self = Self(1000267000);
3063 pub const FRONT_FACE_EXT: Self = Self(1000267001);
3064 pub const PRIMITIVE_TOPOLOGY_EXT: Self = Self(1000267002);
3065 pub const VIEWPORT_WITH_COUNT_EXT: Self = Self(1000267003);
3066 pub const SCISSOR_WITH_COUNT_EXT: Self = Self(1000267004);
3067 pub const VERTEX_INPUT_BINDING_STRIDE_EXT: Self = Self(1000267005);
3068 pub const DEPTH_TEST_ENABLE_EXT: Self = Self(1000267006);
3069 pub const DEPTH_WRITE_ENABLE_EXT: Self = Self(1000267007);
3070 pub const DEPTH_COMPARE_OP_EXT: Self = Self(1000267008);
3071 pub const DEPTH_BOUNDS_TEST_ENABLE_EXT: Self = Self(1000267009);
3072 pub const STENCIL_TEST_ENABLE_EXT: Self = Self(1000267010);
3073 pub const STENCIL_OP_EXT: Self = Self(1000267011);
3074 pub const VERTEX_INPUT_EXT: Self = Self(1000352000);
3075 pub const PATCH_CONTROL_POINTS_EXT: Self = Self(1000377000);
3076 pub const RASTERIZER_DISCARD_ENABLE_EXT: Self = Self(1000377001);
3077 pub const DEPTH_BIAS_ENABLE_EXT: Self = Self(1000377002);
3078 pub const LOGIC_OP_EXT: Self = Self(1000377003);
3079 pub const PRIMITIVE_RESTART_ENABLE_EXT: Self = Self(1000377004);
3080 pub const COLOR_WRITE_ENABLE_EXT: Self = Self(1000381000);
3081 pub const DEPTH_CLAMP_ENABLE_EXT: Self = Self(1000455003);
3082 pub const POLYGON_MODE_EXT: Self = Self(1000455004);
3083 pub const RASTERIZATION_SAMPLES_EXT: Self = Self(1000455005);
3084 pub const SAMPLE_MASK_EXT: Self = Self(1000455006);
3085 pub const ALPHA_TO_COVERAGE_ENABLE_EXT: Self = Self(1000455007);
3086 pub const ALPHA_TO_ONE_ENABLE_EXT: Self = Self(1000455008);
3087 pub const LOGIC_OP_ENABLE_EXT: Self = Self(1000455009);
3088 pub const COLOR_BLEND_ENABLE_EXT: Self = Self(1000455010);
3089 pub const COLOR_BLEND_EQUATION_EXT: Self = Self(1000455011);
3090 pub const COLOR_WRITE_MASK_EXT: Self = Self(1000455012);
3091 pub const TESSELLATION_DOMAIN_ORIGIN_EXT: Self = Self(1000455002);
3092 pub const RASTERIZATION_STREAM_EXT: Self = Self(1000455013);
3093 pub const CONSERVATIVE_RASTERIZATION_MODE_EXT: Self = Self(1000455014);
3094 pub const EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: Self = Self(1000455015);
3095 pub const DEPTH_CLIP_ENABLE_EXT: Self = Self(1000455016);
3096 pub const SAMPLE_LOCATIONS_ENABLE_EXT: Self = Self(1000455017);
3097 pub const COLOR_BLEND_ADVANCED_EXT: Self = Self(1000455018);
3098 pub const PROVOKING_VERTEX_MODE_EXT: Self = Self(1000455019);
3099 pub const LINE_RASTERIZATION_MODE_EXT: Self = Self(1000455020);
3100 pub const LINE_STIPPLE_ENABLE_EXT: Self = Self(1000455021);
3101 pub const DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: Self = Self(1000455022);
3102 pub const VIEWPORT_W_SCALING_ENABLE_NV: Self = Self(1000455023);
3103 pub const VIEWPORT_SWIZZLE_NV: Self = Self(1000455024);
3104 pub const COVERAGE_TO_COLOR_ENABLE_NV: Self = Self(1000455025);
3105 pub const COVERAGE_TO_COLOR_LOCATION_NV: Self = Self(1000455026);
3106 pub const COVERAGE_MODULATION_MODE_NV: Self = Self(1000455027);
3107 pub const COVERAGE_MODULATION_TABLE_ENABLE_NV: Self = Self(1000455028);
3108 pub const COVERAGE_MODULATION_TABLE_NV: Self = Self(1000455029);
3109 pub const SHADING_RATE_IMAGE_ENABLE_NV: Self = Self(1000455030);
3110 pub const REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: Self = Self(1000455031);
3111 pub const COVERAGE_REDUCTION_MODE_NV: Self = Self(1000455032);
3112 pub const ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: Self = Self(1000524000);
3113 pub const LINE_STIPPLE_KHR: Self = Self(1000259000);
3114 pub const DEPTH_CLAMP_RANGE_EXT: Self = Self(1000582000);
3115}
3116
3117#[repr(transparent)]
3118#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3119pub struct DescriptorUpdateTemplateType(pub i32);
3120impl DescriptorUpdateTemplateType {
3121 pub const fn from_raw(value: i32) -> Self {
3122 Self(value)
3123 }
3124
3125 pub const fn as_raw(self) -> i32 {
3126 self.0
3127 }
3128
3129 pub const fn empty() -> Self {
3130 Self(0)
3131 }
3132
3133 pub const DESCRIPTOR_SET: Self = Self(0);
3134 pub const PUSH_DESCRIPTORS: Self = Self(1);
3135 pub const PUSH_DESCRIPTORS_KHR: Self = Self(1);
3136 pub const DESCRIPTOR_SET_KHR: Self = Self(0);
3137}
3138
3139#[repr(transparent)]
3140#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3141pub struct ObjectType(pub i32);
3142impl ObjectType {
3143 pub const fn from_raw(value: i32) -> Self {
3144 Self(value)
3145 }
3146
3147 pub const fn as_raw(self) -> i32 {
3148 self.0
3149 }
3150
3151 pub const fn empty() -> Self {
3152 Self(0)
3153 }
3154
3155 pub const UNKNOWN: Self = Self(0);
3156 pub const INSTANCE: Self = Self(1);
3157 pub const PHYSICAL_DEVICE: Self = Self(2);
3158 pub const DEVICE: Self = Self(3);
3159 pub const QUEUE: Self = Self(4);
3160 pub const SEMAPHORE: Self = Self(5);
3161 pub const COMMAND_BUFFER: Self = Self(6);
3162 pub const FENCE: Self = Self(7);
3163 pub const DEVICE_MEMORY: Self = Self(8);
3164 pub const BUFFER: Self = Self(9);
3165 pub const IMAGE: Self = Self(10);
3166 pub const EVENT: Self = Self(11);
3167 pub const QUERY_POOL: Self = Self(12);
3168 pub const BUFFER_VIEW: Self = Self(13);
3169 pub const IMAGE_VIEW: Self = Self(14);
3170 pub const SHADER_MODULE: Self = Self(15);
3171 pub const PIPELINE_CACHE: Self = Self(16);
3172 pub const PIPELINE_LAYOUT: Self = Self(17);
3173 pub const RENDER_PASS: Self = Self(18);
3174 pub const PIPELINE: Self = Self(19);
3175 pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20);
3176 pub const SAMPLER: Self = Self(21);
3177 pub const DESCRIPTOR_POOL: Self = Self(22);
3178 pub const DESCRIPTOR_SET: Self = Self(23);
3179 pub const FRAMEBUFFER: Self = Self(24);
3180 pub const COMMAND_POOL: Self = Self(25);
3181 pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1000085000);
3182 pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1000156000);
3183 pub const PRIVATE_DATA_SLOT: Self = Self(1000295000);
3184 pub const SURFACE_KHR: Self = Self(1000000000);
3185 pub const SWAPCHAIN_KHR: Self = Self(1000001000);
3186 pub const DISPLAY_KHR: Self = Self(1000002000);
3187 pub const DISPLAY_MODE_KHR: Self = Self(1000002001);
3188 pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(1000011000);
3189 pub const VIDEO_SESSION_KHR: Self = Self(1000023000);
3190 pub const VIDEO_SESSION_PARAMETERS_KHR: Self = Self(1000023001);
3191 pub const CU_MODULE_NVX: Self = Self(1000029000);
3192 pub const CU_FUNCTION_NVX: Self = Self(1000029001);
3193 pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self(1000085000);
3194 pub const DEBUG_UTILS_MESSENGER_EXT: Self = Self(1000128000);
3195 pub const GPA_SESSION_AMD: Self = Self(1000133000);
3196 pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1000150000);
3197 pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self(1000156000);
3198 pub const VALIDATION_CACHE_EXT: Self = Self(1000160000);
3199 pub const ACCELERATION_STRUCTURE_NV: Self = Self(1000165000);
3200 pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1000210000);
3201 pub const DEFERRED_OPERATION_KHR: Self = Self(1000268000);
3202 pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1000277000);
3203 pub const PRIVATE_DATA_SLOT_EXT: Self = Self(1000295000);
3204 #[cfg(feature = "provisional")]
3205 pub const CUDA_MODULE_NV: Self = Self(1000307000);
3206 #[cfg(feature = "provisional")]
3207 pub const CUDA_FUNCTION_NV: Self = Self(1000307001);
3208 #[cfg(feature = "platform-fuchsia")]
3209 pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1000366000);
3210 pub const MICROMAP_EXT: Self = Self(1000396000);
3211 pub const TENSOR_ARM: Self = Self(1000460000);
3212 pub const TENSOR_VIEW_ARM: Self = Self(1000460001);
3213 pub const OPTICAL_FLOW_SESSION_NV: Self = Self(1000464000);
3214 pub const SHADER_EXT: Self = Self(1000482000);
3215 pub const PIPELINE_BINARY_KHR: Self = Self(1000483000);
3216 pub const DATA_GRAPH_PIPELINE_SESSION_ARM: Self = Self(1000507000);
3217 pub const EXTERNAL_COMPUTE_QUEUE_NV: Self = Self(1000556000);
3218 pub const INDIRECT_COMMANDS_LAYOUT_EXT: Self = Self(1000572000);
3219 pub const INDIRECT_EXECUTION_SET_EXT: Self = Self(1000572001);
3220 pub const SHADER_INSTRUMENTATION_ARM: Self = Self(1000607000);
3221}
3222
3223#[repr(transparent)]
3224#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3225pub struct RayTracingInvocationReorderModeEXT(pub i32);
3226impl RayTracingInvocationReorderModeEXT {
3227 pub const fn from_raw(value: i32) -> Self {
3228 Self(value)
3229 }
3230
3231 pub const fn as_raw(self) -> i32 {
3232 self.0
3233 }
3234
3235 pub const fn empty() -> Self {
3236 Self(0)
3237 }
3238
3239 pub const NONE_EXT: Self = Self(0);
3240 pub const REORDER_EXT: Self = Self(1);
3241 pub const NONE_NV: Self = Self(0);
3242 pub const REORDER_NV: Self = Self(1);
3243}
3244
3245#[repr(transparent)]
3246#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3247pub struct RayTracingLssIndexingModeNV(pub i32);
3248impl RayTracingLssIndexingModeNV {
3249 pub const fn from_raw(value: i32) -> Self {
3250 Self(value)
3251 }
3252
3253 pub const fn as_raw(self) -> i32 {
3254 self.0
3255 }
3256
3257 pub const fn empty() -> Self {
3258 Self(0)
3259 }
3260
3261 pub const LIST_NV: Self = Self(0);
3262 pub const SUCCESSIVE_NV: Self = Self(1);
3263}
3264
3265#[repr(transparent)]
3266#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3267pub struct RayTracingLssPrimitiveEndCapsModeNV(pub i32);
3268impl RayTracingLssPrimitiveEndCapsModeNV {
3269 pub const fn from_raw(value: i32) -> Self {
3270 Self(value)
3271 }
3272
3273 pub const fn as_raw(self) -> i32 {
3274 self.0
3275 }
3276
3277 pub const fn empty() -> Self {
3278 Self(0)
3279 }
3280
3281 pub const NONE_NV: Self = Self(0);
3282 pub const CHAINED_NV: Self = Self(1);
3283}
3284
3285#[repr(transparent)]
3286#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3287pub struct DirectDriverLoadingModeLUNARG(pub i32);
3288impl DirectDriverLoadingModeLUNARG {
3289 pub const fn from_raw(value: i32) -> Self {
3290 Self(value)
3291 }
3292
3293 pub const fn as_raw(self) -> i32 {
3294 self.0
3295 }
3296
3297 pub const fn empty() -> Self {
3298 Self(0)
3299 }
3300
3301 pub const DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG: Self = Self(0);
3302 pub const DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG: Self = Self(1);
3303}
3304
3305#[repr(transparent)]
3306#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3307pub struct AntiLagModeAMD(pub i32);
3308impl AntiLagModeAMD {
3309 pub const fn from_raw(value: i32) -> Self {
3310 Self(value)
3311 }
3312
3313 pub const fn as_raw(self) -> i32 {
3314 self.0
3315 }
3316
3317 pub const fn empty() -> Self {
3318 Self(0)
3319 }
3320
3321 pub const DRIVER_CONTROL_AMD: Self = Self(0);
3322 pub const ON_AMD: Self = Self(1);
3323 pub const OFF_AMD: Self = Self(2);
3324}
3325
3326#[repr(transparent)]
3327#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3328pub struct AntiLagStageAMD(pub i32);
3329impl AntiLagStageAMD {
3330 pub const fn from_raw(value: i32) -> Self {
3331 Self(value)
3332 }
3333
3334 pub const fn as_raw(self) -> i32 {
3335 self.0
3336 }
3337
3338 pub const fn empty() -> Self {
3339 Self(0)
3340 }
3341
3342 pub const INPUT_AMD: Self = Self(0);
3343 pub const PRESENT_AMD: Self = Self(1);
3344}
3345
3346#[repr(transparent)]
3347#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3348pub struct QueueFlagBits(pub u32);
3349impl QueueFlagBits {
3350 pub const fn from_raw(value: u32) -> Self {
3351 Self(value)
3352 }
3353
3354 pub const fn as_raw(self) -> u32 {
3355 self.0
3356 }
3357
3358 pub const fn empty() -> Self {
3359 Self(0)
3360 }
3361
3362 pub const GRAPHICS_BIT: Self = Self(1);
3363 pub const COMPUTE_BIT: Self = Self(2);
3364 pub const TRANSFER_BIT: Self = Self(4);
3365 pub const SPARSE_BINDING_BIT: Self = Self(8);
3366 pub const PROTECTED_BIT: Self = Self(16);
3367 pub const VIDEO_DECODE_BIT_KHR: Self = Self(32);
3368 pub const VIDEO_ENCODE_BIT_KHR: Self = Self(64);
3369 pub const OPTICAL_FLOW_BIT_NV: Self = Self(256);
3370 pub const DATA_GRAPH_BIT_ARM: Self = Self(1024);
3371}
3372
3373impl std::ops::BitOr for QueueFlagBits {
3374 type Output = Self;
3375 fn bitor(self, rhs: Self) -> Self {
3376 Self(self.0 | rhs.0)
3377 }
3378}
3379
3380impl std::ops::BitAnd for QueueFlagBits {
3381 type Output = Self;
3382 fn bitand(self, rhs: Self) -> Self {
3383 Self(self.0 & rhs.0)
3384 }
3385}
3386
3387impl std::ops::BitXor for QueueFlagBits {
3388 type Output = Self;
3389 fn bitxor(self, rhs: Self) -> Self {
3390 Self(self.0 ^ rhs.0)
3391 }
3392}
3393
3394impl std::ops::Not for QueueFlagBits {
3395 type Output = Self;
3396 fn not(self) -> Self {
3397 Self(!self.0)
3398 }
3399}
3400
3401#[repr(transparent)]
3402#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3403pub struct CullModeFlagBits(pub u32);
3404impl CullModeFlagBits {
3405 pub const fn from_raw(value: u32) -> Self {
3406 Self(value)
3407 }
3408
3409 pub const fn as_raw(self) -> u32 {
3410 self.0
3411 }
3412
3413 pub const fn empty() -> Self {
3414 Self(0)
3415 }
3416
3417 pub const NONE: Self = Self(0);
3418 pub const FRONT_BIT: Self = Self(1);
3419 pub const BACK_BIT: Self = Self(2);
3420 pub const FRONT_AND_BACK: Self = Self(3);
3421}
3422
3423impl std::ops::BitOr for CullModeFlagBits {
3424 type Output = Self;
3425 fn bitor(self, rhs: Self) -> Self {
3426 Self(self.0 | rhs.0)
3427 }
3428}
3429
3430impl std::ops::BitAnd for CullModeFlagBits {
3431 type Output = Self;
3432 fn bitand(self, rhs: Self) -> Self {
3433 Self(self.0 & rhs.0)
3434 }
3435}
3436
3437impl std::ops::BitXor for CullModeFlagBits {
3438 type Output = Self;
3439 fn bitxor(self, rhs: Self) -> Self {
3440 Self(self.0 ^ rhs.0)
3441 }
3442}
3443
3444impl std::ops::Not for CullModeFlagBits {
3445 type Output = Self;
3446 fn not(self) -> Self {
3447 Self(!self.0)
3448 }
3449}
3450
3451#[repr(transparent)]
3452#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3453pub struct RenderPassCreateFlagBits(pub u32);
3454impl RenderPassCreateFlagBits {
3455 pub const fn from_raw(value: u32) -> Self {
3456 Self(value)
3457 }
3458
3459 pub const fn as_raw(self) -> u32 {
3460 self.0
3461 }
3462
3463 pub const fn empty() -> Self {
3464 Self(0)
3465 }
3466
3467 pub const TRANSFORM_BIT_QCOM: Self = Self(2);
3468 pub const PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: Self = Self(4);
3469}
3470
3471impl std::ops::BitOr for RenderPassCreateFlagBits {
3472 type Output = Self;
3473 fn bitor(self, rhs: Self) -> Self {
3474 Self(self.0 | rhs.0)
3475 }
3476}
3477
3478impl std::ops::BitAnd for RenderPassCreateFlagBits {
3479 type Output = Self;
3480 fn bitand(self, rhs: Self) -> Self {
3481 Self(self.0 & rhs.0)
3482 }
3483}
3484
3485impl std::ops::BitXor for RenderPassCreateFlagBits {
3486 type Output = Self;
3487 fn bitxor(self, rhs: Self) -> Self {
3488 Self(self.0 ^ rhs.0)
3489 }
3490}
3491
3492impl std::ops::Not for RenderPassCreateFlagBits {
3493 type Output = Self;
3494 fn not(self) -> Self {
3495 Self(!self.0)
3496 }
3497}
3498
3499#[repr(transparent)]
3500#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3501pub struct DeviceQueueCreateFlagBits(pub u32);
3502impl DeviceQueueCreateFlagBits {
3503 pub const fn from_raw(value: u32) -> Self {
3504 Self(value)
3505 }
3506
3507 pub const fn as_raw(self) -> u32 {
3508 self.0
3509 }
3510
3511 pub const fn empty() -> Self {
3512 Self(0)
3513 }
3514
3515 pub const PROTECTED_BIT: Self = Self(1);
3516 pub const INTERNALLY_SYNCHRONIZED_BIT_KHR: Self = Self(4);
3517}
3518
3519impl std::ops::BitOr for DeviceQueueCreateFlagBits {
3520 type Output = Self;
3521 fn bitor(self, rhs: Self) -> Self {
3522 Self(self.0 | rhs.0)
3523 }
3524}
3525
3526impl std::ops::BitAnd for DeviceQueueCreateFlagBits {
3527 type Output = Self;
3528 fn bitand(self, rhs: Self) -> Self {
3529 Self(self.0 & rhs.0)
3530 }
3531}
3532
3533impl std::ops::BitXor for DeviceQueueCreateFlagBits {
3534 type Output = Self;
3535 fn bitxor(self, rhs: Self) -> Self {
3536 Self(self.0 ^ rhs.0)
3537 }
3538}
3539
3540impl std::ops::Not for DeviceQueueCreateFlagBits {
3541 type Output = Self;
3542 fn not(self) -> Self {
3543 Self(!self.0)
3544 }
3545}
3546
3547#[repr(transparent)]
3548#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3549pub struct MemoryPropertyFlagBits(pub u32);
3550impl MemoryPropertyFlagBits {
3551 pub const fn from_raw(value: u32) -> Self {
3552 Self(value)
3553 }
3554
3555 pub const fn as_raw(self) -> u32 {
3556 self.0
3557 }
3558
3559 pub const fn empty() -> Self {
3560 Self(0)
3561 }
3562
3563 pub const DEVICE_LOCAL_BIT: Self = Self(1);
3564 pub const HOST_VISIBLE_BIT: Self = Self(2);
3565 pub const HOST_COHERENT_BIT: Self = Self(4);
3566 pub const HOST_CACHED_BIT: Self = Self(8);
3567 pub const LAZILY_ALLOCATED_BIT: Self = Self(16);
3568 pub const PROTECTED_BIT: Self = Self(32);
3569 pub const DEVICE_COHERENT_BIT_AMD: Self = Self(64);
3570 pub const DEVICE_UNCACHED_BIT_AMD: Self = Self(128);
3571 pub const RDMA_CAPABLE_BIT_NV: Self = Self(256);
3572}
3573
3574impl std::ops::BitOr for MemoryPropertyFlagBits {
3575 type Output = Self;
3576 fn bitor(self, rhs: Self) -> Self {
3577 Self(self.0 | rhs.0)
3578 }
3579}
3580
3581impl std::ops::BitAnd for MemoryPropertyFlagBits {
3582 type Output = Self;
3583 fn bitand(self, rhs: Self) -> Self {
3584 Self(self.0 & rhs.0)
3585 }
3586}
3587
3588impl std::ops::BitXor for MemoryPropertyFlagBits {
3589 type Output = Self;
3590 fn bitxor(self, rhs: Self) -> Self {
3591 Self(self.0 ^ rhs.0)
3592 }
3593}
3594
3595impl std::ops::Not for MemoryPropertyFlagBits {
3596 type Output = Self;
3597 fn not(self) -> Self {
3598 Self(!self.0)
3599 }
3600}
3601
3602#[repr(transparent)]
3603#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3604pub struct MemoryHeapFlagBits(pub u32);
3605impl MemoryHeapFlagBits {
3606 pub const fn from_raw(value: u32) -> Self {
3607 Self(value)
3608 }
3609
3610 pub const fn as_raw(self) -> u32 {
3611 self.0
3612 }
3613
3614 pub const fn empty() -> Self {
3615 Self(0)
3616 }
3617
3618 pub const DEVICE_LOCAL_BIT: Self = Self(1);
3619 pub const MULTI_INSTANCE_BIT: Self = Self(2);
3620 pub const MULTI_INSTANCE_BIT_KHR: Self = Self(2);
3621 pub const TILE_MEMORY_BIT_QCOM: Self = Self(8);
3622}
3623
3624impl std::ops::BitOr for MemoryHeapFlagBits {
3625 type Output = Self;
3626 fn bitor(self, rhs: Self) -> Self {
3627 Self(self.0 | rhs.0)
3628 }
3629}
3630
3631impl std::ops::BitAnd for MemoryHeapFlagBits {
3632 type Output = Self;
3633 fn bitand(self, rhs: Self) -> Self {
3634 Self(self.0 & rhs.0)
3635 }
3636}
3637
3638impl std::ops::BitXor for MemoryHeapFlagBits {
3639 type Output = Self;
3640 fn bitxor(self, rhs: Self) -> Self {
3641 Self(self.0 ^ rhs.0)
3642 }
3643}
3644
3645impl std::ops::Not for MemoryHeapFlagBits {
3646 type Output = Self;
3647 fn not(self) -> Self {
3648 Self(!self.0)
3649 }
3650}
3651
3652#[repr(transparent)]
3653#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3654pub struct AccessFlagBits(pub u32);
3655impl AccessFlagBits {
3656 pub const fn from_raw(value: u32) -> Self {
3657 Self(value)
3658 }
3659
3660 pub const fn as_raw(self) -> u32 {
3661 self.0
3662 }
3663
3664 pub const fn empty() -> Self {
3665 Self(0)
3666 }
3667
3668 pub const INDIRECT_COMMAND_READ_BIT: Self = Self(1);
3669 pub const INDEX_READ_BIT: Self = Self(2);
3670 pub const VERTEX_ATTRIBUTE_READ_BIT: Self = Self(4);
3671 pub const UNIFORM_READ_BIT: Self = Self(8);
3672 pub const INPUT_ATTACHMENT_READ_BIT: Self = Self(16);
3673 pub const SHADER_READ_BIT: Self = Self(32);
3674 pub const SHADER_WRITE_BIT: Self = Self(64);
3675 pub const COLOR_ATTACHMENT_READ_BIT: Self = Self(128);
3676 pub const COLOR_ATTACHMENT_WRITE_BIT: Self = Self(256);
3677 pub const DEPTH_STENCIL_ATTACHMENT_READ_BIT: Self = Self(512);
3678 pub const DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: Self = Self(1024);
3679 pub const TRANSFER_READ_BIT: Self = Self(2048);
3680 pub const TRANSFER_WRITE_BIT: Self = Self(4096);
3681 pub const HOST_READ_BIT: Self = Self(8192);
3682 pub const HOST_WRITE_BIT: Self = Self(16384);
3683 pub const MEMORY_READ_BIT: Self = Self(32768);
3684 pub const MEMORY_WRITE_BIT: Self = Self(65536);
3685 pub const NONE: Self = Self(0);
3686 pub const TRANSFORM_FEEDBACK_WRITE_BIT_EXT: Self = Self(33554432);
3687 pub const TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: Self = Self(67108864);
3688 pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: Self = Self(134217728);
3689 pub const CONDITIONAL_RENDERING_READ_BIT_EXT: Self = Self(1048576);
3690 pub const COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: Self = Self(524288);
3691 pub const ACCELERATION_STRUCTURE_READ_BIT_KHR: Self = Self(2097152);
3692 pub const ACCELERATION_STRUCTURE_WRITE_BIT_KHR: Self = Self(4194304);
3693 pub const SHADING_RATE_IMAGE_READ_BIT_NV: Self = Self(8388608);
3694 pub const ACCELERATION_STRUCTURE_READ_BIT_NV: Self = Self(2097152);
3695 pub const ACCELERATION_STRUCTURE_WRITE_BIT_NV: Self = Self(4194304);
3696 pub const FRAGMENT_DENSITY_MAP_READ_BIT_EXT: Self = Self(16777216);
3697 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: Self = Self(8388608);
3698 pub const COMMAND_PREPROCESS_READ_BIT_NV: Self = Self(131072);
3699 pub const COMMAND_PREPROCESS_WRITE_BIT_NV: Self = Self(262144);
3700 pub const NONE_KHR: Self = Self(0);
3701 pub const COMMAND_PREPROCESS_READ_BIT_EXT: Self = Self(131072);
3702 pub const COMMAND_PREPROCESS_WRITE_BIT_EXT: Self = Self(262144);
3703}
3704
3705impl std::ops::BitOr for AccessFlagBits {
3706 type Output = Self;
3707 fn bitor(self, rhs: Self) -> Self {
3708 Self(self.0 | rhs.0)
3709 }
3710}
3711
3712impl std::ops::BitAnd for AccessFlagBits {
3713 type Output = Self;
3714 fn bitand(self, rhs: Self) -> Self {
3715 Self(self.0 & rhs.0)
3716 }
3717}
3718
3719impl std::ops::BitXor for AccessFlagBits {
3720 type Output = Self;
3721 fn bitxor(self, rhs: Self) -> Self {
3722 Self(self.0 ^ rhs.0)
3723 }
3724}
3725
3726impl std::ops::Not for AccessFlagBits {
3727 type Output = Self;
3728 fn not(self) -> Self {
3729 Self(!self.0)
3730 }
3731}
3732
3733#[repr(transparent)]
3734#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3735pub struct BufferUsageFlagBits(pub u32);
3736impl BufferUsageFlagBits {
3737 pub const fn from_raw(value: u32) -> Self {
3738 Self(value)
3739 }
3740
3741 pub const fn as_raw(self) -> u32 {
3742 self.0
3743 }
3744
3745 pub const fn empty() -> Self {
3746 Self(0)
3747 }
3748
3749 pub const TRANSFER_SRC_BIT: Self = Self(1);
3750 pub const TRANSFER_DST_BIT: Self = Self(2);
3751 pub const UNIFORM_TEXEL_BUFFER_BIT: Self = Self(4);
3752 pub const STORAGE_TEXEL_BUFFER_BIT: Self = Self(8);
3753 pub const UNIFORM_BUFFER_BIT: Self = Self(16);
3754 pub const STORAGE_BUFFER_BIT: Self = Self(32);
3755 pub const INDEX_BUFFER_BIT: Self = Self(64);
3756 pub const VERTEX_BUFFER_BIT: Self = Self(128);
3757 pub const INDIRECT_BUFFER_BIT: Self = Self(256);
3758 pub const SHADER_DEVICE_ADDRESS_BIT: Self = Self(131072);
3759 pub const VIDEO_DECODE_SRC_BIT_KHR: Self = Self(8192);
3760 pub const VIDEO_DECODE_DST_BIT_KHR: Self = Self(16384);
3761 pub const TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: Self = Self(2048);
3762 pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: Self = Self(4096);
3763 pub const CONDITIONAL_RENDERING_BIT_EXT: Self = Self(512);
3764 #[cfg(feature = "provisional")]
3765 pub const EXECUTION_GRAPH_SCRATCH_BIT_AMDX: Self = Self(33554432);
3766 pub const DESCRIPTOR_HEAP_BIT_EXT: Self = Self(268435456);
3767 pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: Self = Self(524288);
3768 pub const ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: Self = Self(1048576);
3769 pub const SHADER_BINDING_TABLE_BIT_KHR: Self = Self(1024);
3770 pub const RAY_TRACING_BIT_NV: Self = Self(1024);
3771 pub const SHADER_DEVICE_ADDRESS_BIT_EXT: Self = Self(131072);
3772 pub const SHADER_DEVICE_ADDRESS_BIT_KHR: Self = Self(131072);
3773 pub const VIDEO_ENCODE_DST_BIT_KHR: Self = Self(32768);
3774 pub const VIDEO_ENCODE_SRC_BIT_KHR: Self = Self(65536);
3775 pub const SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(2097152);
3776 pub const RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(4194304);
3777 pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(67108864);
3778 pub const MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: Self = Self(8388608);
3779 pub const MICROMAP_STORAGE_BIT_EXT: Self = Self(16777216);
3780 pub const TILE_MEMORY_BIT_QCOM: Self = Self(134217728);
3781}
3782
3783impl std::ops::BitOr for BufferUsageFlagBits {
3784 type Output = Self;
3785 fn bitor(self, rhs: Self) -> Self {
3786 Self(self.0 | rhs.0)
3787 }
3788}
3789
3790impl std::ops::BitAnd for BufferUsageFlagBits {
3791 type Output = Self;
3792 fn bitand(self, rhs: Self) -> Self {
3793 Self(self.0 & rhs.0)
3794 }
3795}
3796
3797impl std::ops::BitXor for BufferUsageFlagBits {
3798 type Output = Self;
3799 fn bitxor(self, rhs: Self) -> Self {
3800 Self(self.0 ^ rhs.0)
3801 }
3802}
3803
3804impl std::ops::Not for BufferUsageFlagBits {
3805 type Output = Self;
3806 fn not(self) -> Self {
3807 Self(!self.0)
3808 }
3809}
3810
3811#[repr(transparent)]
3812#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3813pub struct BufferUsageFlagBits2(pub u64);
3814impl BufferUsageFlagBits2 {
3815 pub const fn from_raw(value: u64) -> Self {
3816 Self(value)
3817 }
3818
3819 pub const fn as_raw(self) -> u64 {
3820 self.0
3821 }
3822
3823 pub const fn empty() -> Self {
3824 Self(0)
3825 }
3826
3827 pub const TRANSFER_SRC_BIT: Self = Self(1);
3828 pub const TRANSFER_DST_BIT: Self = Self(2);
3829 pub const UNIFORM_TEXEL_BUFFER_BIT: Self = Self(4);
3830 pub const STORAGE_TEXEL_BUFFER_BIT: Self = Self(8);
3831 pub const UNIFORM_BUFFER_BIT: Self = Self(16);
3832 pub const STORAGE_BUFFER_BIT: Self = Self(32);
3833 pub const INDEX_BUFFER_BIT: Self = Self(64);
3834 pub const VERTEX_BUFFER_BIT: Self = Self(128);
3835 pub const INDIRECT_BUFFER_BIT: Self = Self(256);
3836 pub const SHADER_DEVICE_ADDRESS_BIT: Self = Self(131072);
3837 #[cfg(feature = "provisional")]
3838 pub const EXECUTION_GRAPH_SCRATCH_BIT_AMDX: Self = Self(33554432);
3839 pub const DESCRIPTOR_HEAP_BIT_EXT: Self = Self(268435456);
3840 pub const MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: Self = Self(8388608);
3841 pub const MICROMAP_STORAGE_BIT_EXT: Self = Self(16777216);
3842 pub const TRANSFER_SRC_BIT_KHR: Self = Self(1);
3843 pub const TRANSFER_DST_BIT_KHR: Self = Self(2);
3844 pub const UNIFORM_TEXEL_BUFFER_BIT_KHR: Self = Self(4);
3845 pub const STORAGE_TEXEL_BUFFER_BIT_KHR: Self = Self(8);
3846 pub const UNIFORM_BUFFER_BIT_KHR: Self = Self(16);
3847 pub const STORAGE_BUFFER_BIT_KHR: Self = Self(32);
3848 pub const INDEX_BUFFER_BIT_KHR: Self = Self(64);
3849 pub const VERTEX_BUFFER_BIT_KHR: Self = Self(128);
3850 pub const INDIRECT_BUFFER_BIT_KHR: Self = Self(256);
3851 pub const CONDITIONAL_RENDERING_BIT_EXT: Self = Self(512);
3852 pub const SHADER_BINDING_TABLE_BIT_KHR: Self = Self(1024);
3853 pub const RAY_TRACING_BIT_NV: Self = Self(1024);
3854 pub const TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: Self = Self(2048);
3855 pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: Self = Self(4096);
3856 pub const VIDEO_DECODE_SRC_BIT_KHR: Self = Self(8192);
3857 pub const VIDEO_DECODE_DST_BIT_KHR: Self = Self(16384);
3858 pub const VIDEO_ENCODE_DST_BIT_KHR: Self = Self(32768);
3859 pub const VIDEO_ENCODE_SRC_BIT_KHR: Self = Self(65536);
3860 pub const SHADER_DEVICE_ADDRESS_BIT_KHR: Self = Self(131072);
3861 pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: Self = Self(524288);
3862 pub const ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: Self = Self(1048576);
3863 pub const SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(2097152);
3864 pub const RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(4194304);
3865 pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(67108864);
3866 #[cfg(feature = "provisional")]
3867 pub const COMPRESSED_DATA_DGF1_BIT_AMDX: Self = Self(8589934592);
3868 pub const DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM: Self = Self(536870912);
3869 pub const TILE_MEMORY_BIT_QCOM: Self = Self(134217728);
3870 pub const MEMORY_DECOMPRESSION_BIT_EXT: Self = Self(4294967296);
3871 pub const PREPROCESS_BUFFER_BIT_EXT: Self = Self(2147483648);
3872}
3873
3874impl std::ops::BitOr for BufferUsageFlagBits2 {
3875 type Output = Self;
3876 fn bitor(self, rhs: Self) -> Self {
3877 Self(self.0 | rhs.0)
3878 }
3879}
3880
3881impl std::ops::BitAnd for BufferUsageFlagBits2 {
3882 type Output = Self;
3883 fn bitand(self, rhs: Self) -> Self {
3884 Self(self.0 & rhs.0)
3885 }
3886}
3887
3888impl std::ops::BitXor for BufferUsageFlagBits2 {
3889 type Output = Self;
3890 fn bitxor(self, rhs: Self) -> Self {
3891 Self(self.0 ^ rhs.0)
3892 }
3893}
3894
3895impl std::ops::Not for BufferUsageFlagBits2 {
3896 type Output = Self;
3897 fn not(self) -> Self {
3898 Self(!self.0)
3899 }
3900}
3901
3902#[repr(transparent)]
3903#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3904pub struct BufferCreateFlagBits(pub u32);
3905impl BufferCreateFlagBits {
3906 pub const fn from_raw(value: u32) -> Self {
3907 Self(value)
3908 }
3909
3910 pub const fn as_raw(self) -> u32 {
3911 self.0
3912 }
3913
3914 pub const fn empty() -> Self {
3915 Self(0)
3916 }
3917
3918 pub const SPARSE_BINDING_BIT: Self = Self(1);
3919 pub const SPARSE_RESIDENCY_BIT: Self = Self(2);
3920 pub const SPARSE_ALIASED_BIT: Self = Self(4);
3921 pub const PROTECTED_BIT: Self = Self(8);
3922 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: Self = Self(16);
3923 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: Self = Self(16);
3924 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: Self = Self(16);
3925 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: Self = Self(32);
3926 pub const VIDEO_PROFILE_INDEPENDENT_BIT_KHR: Self = Self(64);
3927}
3928
3929impl std::ops::BitOr for BufferCreateFlagBits {
3930 type Output = Self;
3931 fn bitor(self, rhs: Self) -> Self {
3932 Self(self.0 | rhs.0)
3933 }
3934}
3935
3936impl std::ops::BitAnd for BufferCreateFlagBits {
3937 type Output = Self;
3938 fn bitand(self, rhs: Self) -> Self {
3939 Self(self.0 & rhs.0)
3940 }
3941}
3942
3943impl std::ops::BitXor for BufferCreateFlagBits {
3944 type Output = Self;
3945 fn bitxor(self, rhs: Self) -> Self {
3946 Self(self.0 ^ rhs.0)
3947 }
3948}
3949
3950impl std::ops::Not for BufferCreateFlagBits {
3951 type Output = Self;
3952 fn not(self) -> Self {
3953 Self(!self.0)
3954 }
3955}
3956
3957#[repr(transparent)]
3958#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
3959pub struct ShaderStageFlagBits(pub u32);
3960impl ShaderStageFlagBits {
3961 pub const fn from_raw(value: u32) -> Self {
3962 Self(value)
3963 }
3964
3965 pub const fn as_raw(self) -> u32 {
3966 self.0
3967 }
3968
3969 pub const fn empty() -> Self {
3970 Self(0)
3971 }
3972
3973 pub const VERTEX_BIT: Self = Self(1);
3974 pub const TESSELLATION_CONTROL_BIT: Self = Self(2);
3975 pub const TESSELLATION_EVALUATION_BIT: Self = Self(4);
3976 pub const GEOMETRY_BIT: Self = Self(8);
3977 pub const FRAGMENT_BIT: Self = Self(16);
3978 pub const COMPUTE_BIT: Self = Self(32);
3979 pub const ALL_GRAPHICS: Self = Self(31);
3980 pub const ALL: Self = Self(2147483647);
3981 pub const RAYGEN_BIT_KHR: Self = Self(256);
3982 pub const ANY_HIT_BIT_KHR: Self = Self(512);
3983 pub const CLOSEST_HIT_BIT_KHR: Self = Self(1024);
3984 pub const MISS_BIT_KHR: Self = Self(2048);
3985 pub const INTERSECTION_BIT_KHR: Self = Self(4096);
3986 pub const CALLABLE_BIT_KHR: Self = Self(8192);
3987 pub const RAYGEN_BIT_NV: Self = Self(256);
3988 pub const ANY_HIT_BIT_NV: Self = Self(512);
3989 pub const CLOSEST_HIT_BIT_NV: Self = Self(1024);
3990 pub const MISS_BIT_NV: Self = Self(2048);
3991 pub const INTERSECTION_BIT_NV: Self = Self(4096);
3992 pub const CALLABLE_BIT_NV: Self = Self(8192);
3993 pub const TASK_BIT_NV: Self = Self(64);
3994 pub const MESH_BIT_NV: Self = Self(128);
3995 pub const TASK_BIT_EXT: Self = Self(64);
3996 pub const MESH_BIT_EXT: Self = Self(128);
3997 pub const SUBPASS_SHADING_BIT_HUAWEI: Self = Self(16384);
3998 pub const CLUSTER_CULLING_BIT_HUAWEI: Self = Self(524288);
3999}
4000
4001impl std::ops::BitOr for ShaderStageFlagBits {
4002 type Output = Self;
4003 fn bitor(self, rhs: Self) -> Self {
4004 Self(self.0 | rhs.0)
4005 }
4006}
4007
4008impl std::ops::BitAnd for ShaderStageFlagBits {
4009 type Output = Self;
4010 fn bitand(self, rhs: Self) -> Self {
4011 Self(self.0 & rhs.0)
4012 }
4013}
4014
4015impl std::ops::BitXor for ShaderStageFlagBits {
4016 type Output = Self;
4017 fn bitxor(self, rhs: Self) -> Self {
4018 Self(self.0 ^ rhs.0)
4019 }
4020}
4021
4022impl std::ops::Not for ShaderStageFlagBits {
4023 type Output = Self;
4024 fn not(self) -> Self {
4025 Self(!self.0)
4026 }
4027}
4028
4029#[repr(transparent)]
4030#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4031pub struct ImageUsageFlagBits(pub u32);
4032impl ImageUsageFlagBits {
4033 pub const fn from_raw(value: u32) -> Self {
4034 Self(value)
4035 }
4036
4037 pub const fn as_raw(self) -> u32 {
4038 self.0
4039 }
4040
4041 pub const fn empty() -> Self {
4042 Self(0)
4043 }
4044
4045 pub const TRANSFER_SRC_BIT: Self = Self(1);
4046 pub const TRANSFER_DST_BIT: Self = Self(2);
4047 pub const SAMPLED_BIT: Self = Self(4);
4048 pub const STORAGE_BIT: Self = Self(8);
4049 pub const COLOR_ATTACHMENT_BIT: Self = Self(16);
4050 pub const DEPTH_STENCIL_ATTACHMENT_BIT: Self = Self(32);
4051 pub const TRANSIENT_ATTACHMENT_BIT: Self = Self(64);
4052 pub const INPUT_ATTACHMENT_BIT: Self = Self(128);
4053 pub const HOST_TRANSFER_BIT: Self = Self(4194304);
4054 pub const VIDEO_DECODE_DST_BIT_KHR: Self = Self(1024);
4055 pub const VIDEO_DECODE_SRC_BIT_KHR: Self = Self(2048);
4056 pub const VIDEO_DECODE_DPB_BIT_KHR: Self = Self(4096);
4057 pub const SHADING_RATE_IMAGE_BIT_NV: Self = Self(256);
4058 pub const FRAGMENT_DENSITY_MAP_BIT_EXT: Self = Self(512);
4059 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self = Self(256);
4060 pub const HOST_TRANSFER_BIT_EXT: Self = Self(4194304);
4061 pub const VIDEO_ENCODE_DST_BIT_KHR: Self = Self(8192);
4062 pub const VIDEO_ENCODE_SRC_BIT_KHR: Self = Self(16384);
4063 pub const VIDEO_ENCODE_DPB_BIT_KHR: Self = Self(32768);
4064 pub const ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: Self = Self(524288);
4065 pub const INVOCATION_MASK_BIT_HUAWEI: Self = Self(262144);
4066 pub const SAMPLE_WEIGHT_BIT_QCOM: Self = Self(1048576);
4067 pub const SAMPLE_BLOCK_MATCH_BIT_QCOM: Self = Self(2097152);
4068 pub const TENSOR_ALIASING_BIT_ARM: Self = Self(8388608);
4069 pub const TILE_MEMORY_BIT_QCOM: Self = Self(134217728);
4070 pub const VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: Self = Self(33554432);
4071 pub const VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: Self = Self(67108864);
4072}
4073
4074impl std::ops::BitOr for ImageUsageFlagBits {
4075 type Output = Self;
4076 fn bitor(self, rhs: Self) -> Self {
4077 Self(self.0 | rhs.0)
4078 }
4079}
4080
4081impl std::ops::BitAnd for ImageUsageFlagBits {
4082 type Output = Self;
4083 fn bitand(self, rhs: Self) -> Self {
4084 Self(self.0 & rhs.0)
4085 }
4086}
4087
4088impl std::ops::BitXor for ImageUsageFlagBits {
4089 type Output = Self;
4090 fn bitxor(self, rhs: Self) -> Self {
4091 Self(self.0 ^ rhs.0)
4092 }
4093}
4094
4095impl std::ops::Not for ImageUsageFlagBits {
4096 type Output = Self;
4097 fn not(self) -> Self {
4098 Self(!self.0)
4099 }
4100}
4101
4102#[repr(transparent)]
4103#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4104pub struct ImageUsageFlagBits2KHR(pub u64);
4105impl ImageUsageFlagBits2KHR {
4106 pub const fn from_raw(value: u64) -> Self {
4107 Self(value)
4108 }
4109
4110 pub const fn as_raw(self) -> u64 {
4111 self.0
4112 }
4113
4114 pub const fn empty() -> Self {
4115 Self(0)
4116 }
4117
4118 pub const TRANSFER_SRC_BIT_KHR: Self = Self(1);
4119 pub const TRANSFER_DST_BIT_KHR: Self = Self(2);
4120 pub const SAMPLED_BIT_KHR: Self = Self(4);
4121 pub const STORAGE_BIT_KHR: Self = Self(8);
4122 pub const COLOR_ATTACHMENT_BIT_KHR: Self = Self(16);
4123 pub const DEPTH_STENCIL_ATTACHMENT_BIT_KHR: Self = Self(32);
4124 pub const TRANSIENT_ATTACHMENT_BIT_KHR: Self = Self(64);
4125 pub const INPUT_ATTACHMENT_BIT_KHR: Self = Self(128);
4126 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self = Self(256);
4127 pub const FRAGMENT_DENSITY_MAP_BIT_EXT: Self = Self(512);
4128 pub const VIDEO_DECODE_DST_BIT_KHR: Self = Self(1024);
4129 pub const VIDEO_DECODE_SRC_BIT_KHR: Self = Self(2048);
4130 pub const VIDEO_DECODE_DPB_BIT_KHR: Self = Self(4096);
4131 pub const VIDEO_ENCODE_DST_BIT_KHR: Self = Self(8192);
4132 pub const VIDEO_ENCODE_SRC_BIT_KHR: Self = Self(16384);
4133 pub const VIDEO_ENCODE_DPB_BIT_KHR: Self = Self(32768);
4134 pub const INVOCATION_MASK_BIT_HUAWEI: Self = Self(262144);
4135 pub const ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: Self = Self(524288);
4136 pub const SAMPLE_WEIGHT_BIT_QCOM: Self = Self(1048576);
4137 pub const SAMPLE_BLOCK_MATCH_BIT_QCOM: Self = Self(2097152);
4138 pub const HOST_TRANSFER_BIT_KHR: Self = Self(4194304);
4139 pub const TENSOR_ALIASING_BIT_ARM: Self = Self(8388608);
4140 pub const VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: Self = Self(33554432);
4141 pub const VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: Self = Self(67108864);
4142 pub const TILE_MEMORY_BIT_QCOM: Self = Self(134217728);
4143}
4144
4145impl std::ops::BitOr for ImageUsageFlagBits2KHR {
4146 type Output = Self;
4147 fn bitor(self, rhs: Self) -> Self {
4148 Self(self.0 | rhs.0)
4149 }
4150}
4151
4152impl std::ops::BitAnd for ImageUsageFlagBits2KHR {
4153 type Output = Self;
4154 fn bitand(self, rhs: Self) -> Self {
4155 Self(self.0 & rhs.0)
4156 }
4157}
4158
4159impl std::ops::BitXor for ImageUsageFlagBits2KHR {
4160 type Output = Self;
4161 fn bitxor(self, rhs: Self) -> Self {
4162 Self(self.0 ^ rhs.0)
4163 }
4164}
4165
4166impl std::ops::Not for ImageUsageFlagBits2KHR {
4167 type Output = Self;
4168 fn not(self) -> Self {
4169 Self(!self.0)
4170 }
4171}
4172
4173#[repr(transparent)]
4174#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4175pub struct ImageCreateFlagBits(pub u32);
4176impl ImageCreateFlagBits {
4177 pub const fn from_raw(value: u32) -> Self {
4178 Self(value)
4179 }
4180
4181 pub const fn as_raw(self) -> u32 {
4182 self.0
4183 }
4184
4185 pub const fn empty() -> Self {
4186 Self(0)
4187 }
4188
4189 pub const SPARSE_BINDING_BIT: Self = Self(1);
4190 pub const SPARSE_RESIDENCY_BIT: Self = Self(2);
4191 pub const SPARSE_ALIASED_BIT: Self = Self(4);
4192 pub const MUTABLE_FORMAT_BIT: Self = Self(8);
4193 pub const CUBE_COMPATIBLE_BIT: Self = Self(16);
4194 pub const ALIAS_BIT: Self = Self(1024);
4195 pub const SPLIT_INSTANCE_BIND_REGIONS_BIT: Self = Self(64);
4196 pub const _2D_ARRAY_COMPATIBLE_BIT: Self = Self(32);
4197 pub const BLOCK_TEXEL_VIEW_COMPATIBLE_BIT: Self = Self(128);
4198 pub const EXTENDED_USAGE_BIT: Self = Self(256);
4199 pub const PROTECTED_BIT: Self = Self(2048);
4200 pub const DISJOINT_BIT: Self = Self(512);
4201 pub const CORNER_SAMPLED_BIT_NV: Self = Self(8192);
4202 pub const SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: Self = Self(64);
4203 pub const _2D_ARRAY_COMPATIBLE_BIT_KHR: Self = Self(32);
4204 pub const BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR: Self = Self(128);
4205 pub const EXTENDED_USAGE_BIT_KHR: Self = Self(256);
4206 pub const DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT: Self = Self(65536);
4207 pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT: Self = Self(4096);
4208 pub const DISJOINT_BIT_KHR: Self = Self(512);
4209 pub const ALIAS_BIT_KHR: Self = Self(1024);
4210 pub const SUBSAMPLED_BIT_EXT: Self = Self(16384);
4211 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: Self = Self(65536);
4212 pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT: Self = Self(262144);
4213 pub const _2D_VIEW_COMPATIBLE_BIT_EXT: Self = Self(131072);
4214 pub const FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM: Self = Self(32768);
4215 pub const VIDEO_PROFILE_INDEPENDENT_BIT_KHR: Self = Self(1048576);
4216 pub const FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT: Self = Self(32768);
4217 pub const ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR: Self = Self(4194304);
4218}
4219
4220impl std::ops::BitOr for ImageCreateFlagBits {
4221 type Output = Self;
4222 fn bitor(self, rhs: Self) -> Self {
4223 Self(self.0 | rhs.0)
4224 }
4225}
4226
4227impl std::ops::BitAnd for ImageCreateFlagBits {
4228 type Output = Self;
4229 fn bitand(self, rhs: Self) -> Self {
4230 Self(self.0 & rhs.0)
4231 }
4232}
4233
4234impl std::ops::BitXor for ImageCreateFlagBits {
4235 type Output = Self;
4236 fn bitxor(self, rhs: Self) -> Self {
4237 Self(self.0 ^ rhs.0)
4238 }
4239}
4240
4241impl std::ops::Not for ImageCreateFlagBits {
4242 type Output = Self;
4243 fn not(self) -> Self {
4244 Self(!self.0)
4245 }
4246}
4247
4248#[repr(transparent)]
4249#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4250pub struct ImageCreateFlagBits2KHR(pub u64);
4251impl ImageCreateFlagBits2KHR {
4252 pub const fn from_raw(value: u64) -> Self {
4253 Self(value)
4254 }
4255
4256 pub const fn as_raw(self) -> u64 {
4257 self.0
4258 }
4259
4260 pub const fn empty() -> Self {
4261 Self(0)
4262 }
4263
4264 pub const SPARSE_BINDING_BIT_KHR: Self = Self(1);
4265 pub const SPARSE_RESIDENCY_BIT_KHR: Self = Self(2);
4266 pub const SPARSE_ALIASED_BIT_KHR: Self = Self(4);
4267 pub const MUTABLE_FORMAT_BIT_KHR: Self = Self(8);
4268 pub const CUBE_COMPATIBLE_BIT_KHR: Self = Self(16);
4269 pub const ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR: Self = Self(4194304);
4270 pub const _2D_ARRAY_COMPATIBLE_BIT_KHR: Self = Self(32);
4271 pub const SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: Self = Self(64);
4272 pub const BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR: Self = Self(128);
4273 pub const EXTENDED_USAGE_BIT_KHR: Self = Self(256);
4274 pub const DISJOINT_BIT_KHR: Self = Self(512);
4275 pub const ALIAS_BIT_KHR: Self = Self(1024);
4276 pub const PROTECTED_BIT_KHR: Self = Self(2048);
4277 pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT: Self = Self(4096);
4278 pub const CORNER_SAMPLED_BIT_NV: Self = Self(8192);
4279 pub const SUBSAMPLED_BIT_EXT: Self = Self(16384);
4280 pub const FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT: Self = Self(32768);
4281 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: Self = Self(65536);
4282 pub const _2D_VIEW_COMPATIBLE_BIT_EXT: Self = Self(131072);
4283 pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT: Self = Self(262144);
4284 pub const VIDEO_PROFILE_INDEPENDENT_BIT_KHR: Self = Self(1048576);
4285}
4286
4287impl std::ops::BitOr for ImageCreateFlagBits2KHR {
4288 type Output = Self;
4289 fn bitor(self, rhs: Self) -> Self {
4290 Self(self.0 | rhs.0)
4291 }
4292}
4293
4294impl std::ops::BitAnd for ImageCreateFlagBits2KHR {
4295 type Output = Self;
4296 fn bitand(self, rhs: Self) -> Self {
4297 Self(self.0 & rhs.0)
4298 }
4299}
4300
4301impl std::ops::BitXor for ImageCreateFlagBits2KHR {
4302 type Output = Self;
4303 fn bitxor(self, rhs: Self) -> Self {
4304 Self(self.0 ^ rhs.0)
4305 }
4306}
4307
4308impl std::ops::Not for ImageCreateFlagBits2KHR {
4309 type Output = Self;
4310 fn not(self) -> Self {
4311 Self(!self.0)
4312 }
4313}
4314
4315#[repr(transparent)]
4316#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4317pub struct ImageViewCreateFlagBits(pub u32);
4318impl ImageViewCreateFlagBits {
4319 pub const fn from_raw(value: u32) -> Self {
4320 Self(value)
4321 }
4322
4323 pub const fn as_raw(self) -> u32 {
4324 self.0
4325 }
4326
4327 pub const fn empty() -> Self {
4328 Self(0)
4329 }
4330
4331 pub const FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT: Self = Self(1);
4332 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: Self = Self(4);
4333 pub const FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT: Self = Self(2);
4334}
4335
4336impl std::ops::BitOr for ImageViewCreateFlagBits {
4337 type Output = Self;
4338 fn bitor(self, rhs: Self) -> Self {
4339 Self(self.0 | rhs.0)
4340 }
4341}
4342
4343impl std::ops::BitAnd for ImageViewCreateFlagBits {
4344 type Output = Self;
4345 fn bitand(self, rhs: Self) -> Self {
4346 Self(self.0 & rhs.0)
4347 }
4348}
4349
4350impl std::ops::BitXor for ImageViewCreateFlagBits {
4351 type Output = Self;
4352 fn bitxor(self, rhs: Self) -> Self {
4353 Self(self.0 ^ rhs.0)
4354 }
4355}
4356
4357impl std::ops::Not for ImageViewCreateFlagBits {
4358 type Output = Self;
4359 fn not(self) -> Self {
4360 Self(!self.0)
4361 }
4362}
4363
4364#[repr(transparent)]
4365#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4366pub struct SamplerCreateFlagBits(pub u32);
4367impl SamplerCreateFlagBits {
4368 pub const fn from_raw(value: u32) -> Self {
4369 Self(value)
4370 }
4371
4372 pub const fn as_raw(self) -> u32 {
4373 self.0
4374 }
4375
4376 pub const fn empty() -> Self {
4377 Self(0)
4378 }
4379
4380 pub const SUBSAMPLED_BIT_EXT: Self = Self(1);
4381 pub const SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT: Self = Self(2);
4382 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: Self = Self(8);
4383 pub const NON_SEAMLESS_CUBE_MAP_BIT_EXT: Self = Self(4);
4384 pub const IMAGE_PROCESSING_BIT_QCOM: Self = Self(16);
4385}
4386
4387impl std::ops::BitOr for SamplerCreateFlagBits {
4388 type Output = Self;
4389 fn bitor(self, rhs: Self) -> Self {
4390 Self(self.0 | rhs.0)
4391 }
4392}
4393
4394impl std::ops::BitAnd for SamplerCreateFlagBits {
4395 type Output = Self;
4396 fn bitand(self, rhs: Self) -> Self {
4397 Self(self.0 & rhs.0)
4398 }
4399}
4400
4401impl std::ops::BitXor for SamplerCreateFlagBits {
4402 type Output = Self;
4403 fn bitxor(self, rhs: Self) -> Self {
4404 Self(self.0 ^ rhs.0)
4405 }
4406}
4407
4408impl std::ops::Not for SamplerCreateFlagBits {
4409 type Output = Self;
4410 fn not(self) -> Self {
4411 Self(!self.0)
4412 }
4413}
4414
4415#[repr(transparent)]
4416#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4417pub struct PipelineCreateFlagBits(pub u32);
4418impl PipelineCreateFlagBits {
4419 pub const fn from_raw(value: u32) -> Self {
4420 Self(value)
4421 }
4422
4423 pub const fn as_raw(self) -> u32 {
4424 self.0
4425 }
4426
4427 pub const fn empty() -> Self {
4428 Self(0)
4429 }
4430
4431 pub const DISABLE_OPTIMIZATION_BIT: Self = Self(1);
4432 pub const ALLOW_DERIVATIVES_BIT: Self = Self(2);
4433 pub const DERIVATIVE_BIT: Self = Self(4);
4434 pub const DISPATCH_BASE_BIT: Self = Self(16);
4435 pub const DISPATCH_BASE: Self = Self(16);
4436 pub const VIEW_INDEX_FROM_DEVICE_INDEX_BIT: Self = Self(8);
4437 pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: Self = Self(256);
4438 pub const EARLY_RETURN_ON_FAILURE_BIT: Self = Self(512);
4439 pub const NO_PROTECTED_ACCESS_BIT: Self = Self(134217728);
4440 pub const PROTECTED_ACCESS_ONLY_BIT: Self = Self(1073741824);
4441 pub const VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: Self = Self(8);
4442 pub const DISPATCH_BASE_BIT_KHR: Self = Self(16);
4443 pub const DISPATCH_BASE_KHR: Self = Self(16);
4444 pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: Self = Self(16384);
4445 pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: Self = Self(32768);
4446 pub const RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: Self = Self(65536);
4447 pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: Self = Self(131072);
4448 pub const RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: Self = Self(4096);
4449 pub const RAY_TRACING_SKIP_AABBS_BIT_KHR: Self = Self(8192);
4450 pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: Self = Self(524288);
4451 pub const DEFER_COMPILE_BIT_NV: Self = Self(32);
4452 pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: Self = Self(4194304);
4453 pub const PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: Self =
4454 Self(4194304);
4455 pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self = Self(2097152);
4456 pub const PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self =
4457 Self(2097152);
4458 pub const CAPTURE_STATISTICS_BIT_KHR: Self = Self(64);
4459 pub const CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: Self = Self(128);
4460 pub const INDIRECT_BINDABLE_BIT_NV: Self = Self(262144);
4461 pub const LIBRARY_BIT_KHR: Self = Self(2048);
4462 pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT: Self = Self(256);
4463 pub const EARLY_RETURN_ON_FAILURE_BIT_EXT: Self = Self(512);
4464 pub const DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(536870912);
4465 pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: Self = Self(8388608);
4466 pub const LINK_TIME_OPTIMIZATION_BIT_EXT: Self = Self(1024);
4467 pub const RAY_TRACING_ALLOW_MOTION_BIT_NV: Self = Self(1048576);
4468 pub const COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: Self = Self(33554432);
4469 pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: Self = Self(67108864);
4470 pub const RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: Self = Self(16777216);
4471 #[cfg(feature = "provisional")]
4472 pub const RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: Self = Self(268435456);
4473 pub const NO_PROTECTED_ACCESS_BIT_EXT: Self = Self(134217728);
4474 pub const PROTECTED_ACCESS_ONLY_BIT_EXT: Self = Self(1073741824);
4475 pub const RAY_TRACING_OPACITY_MICROMAP_BIT_KHR: Self = Self(16777216);
4476}
4477
4478impl std::ops::BitOr for PipelineCreateFlagBits {
4479 type Output = Self;
4480 fn bitor(self, rhs: Self) -> Self {
4481 Self(self.0 | rhs.0)
4482 }
4483}
4484
4485impl std::ops::BitAnd for PipelineCreateFlagBits {
4486 type Output = Self;
4487 fn bitand(self, rhs: Self) -> Self {
4488 Self(self.0 & rhs.0)
4489 }
4490}
4491
4492impl std::ops::BitXor for PipelineCreateFlagBits {
4493 type Output = Self;
4494 fn bitxor(self, rhs: Self) -> Self {
4495 Self(self.0 ^ rhs.0)
4496 }
4497}
4498
4499impl std::ops::Not for PipelineCreateFlagBits {
4500 type Output = Self;
4501 fn not(self) -> Self {
4502 Self(!self.0)
4503 }
4504}
4505
4506#[repr(transparent)]
4507#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4508pub struct PipelineCreateFlagBits2(pub u64);
4509impl PipelineCreateFlagBits2 {
4510 pub const fn from_raw(value: u64) -> Self {
4511 Self(value)
4512 }
4513
4514 pub const fn as_raw(self) -> u64 {
4515 self.0
4516 }
4517
4518 pub const fn empty() -> Self {
4519 Self(0)
4520 }
4521
4522 pub const DISABLE_OPTIMIZATION_BIT: Self = Self(1);
4523 pub const ALLOW_DERIVATIVES_BIT: Self = Self(2);
4524 pub const DERIVATIVE_BIT: Self = Self(4);
4525 pub const VIEW_INDEX_FROM_DEVICE_INDEX_BIT: Self = Self(8);
4526 pub const DISPATCH_BASE_BIT: Self = Self(16);
4527 pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: Self = Self(256);
4528 pub const EARLY_RETURN_ON_FAILURE_BIT: Self = Self(512);
4529 pub const NO_PROTECTED_ACCESS_BIT: Self = Self(134217728);
4530 pub const PROTECTED_ACCESS_ONLY_BIT: Self = Self(1073741824);
4531 #[cfg(feature = "provisional")]
4532 pub const EXECUTION_GRAPH_BIT_AMDX: Self = Self(4294967296);
4533 pub const DESCRIPTOR_HEAP_BIT_EXT: Self = Self(68719476736);
4534 pub const RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR: Self = Self(4096);
4535 pub const RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: Self = Self(16777216);
4536 pub const RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV: Self = Self(8589934592);
4537 pub const ENABLE_LEGACY_DITHERING_BIT_EXT: Self = Self(17179869184);
4538 pub const DISABLE_OPTIMIZATION_BIT_KHR: Self = Self(1);
4539 pub const ALLOW_DERIVATIVES_BIT_KHR: Self = Self(2);
4540 pub const DERIVATIVE_BIT_KHR: Self = Self(4);
4541 pub const VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: Self = Self(8);
4542 pub const DISPATCH_BASE_BIT_KHR: Self = Self(16);
4543 pub const DEFER_COMPILE_BIT_NV: Self = Self(32);
4544 pub const CAPTURE_STATISTICS_BIT_KHR: Self = Self(64);
4545 pub const CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: Self = Self(128);
4546 pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR: Self = Self(256);
4547 pub const EARLY_RETURN_ON_FAILURE_BIT_KHR: Self = Self(512);
4548 pub const LINK_TIME_OPTIMIZATION_BIT_EXT: Self = Self(1024);
4549 pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: Self = Self(8388608);
4550 pub const LIBRARY_BIT_KHR: Self = Self(2048);
4551 pub const RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: Self = Self(4096);
4552 pub const RAY_TRACING_SKIP_AABBS_BIT_KHR: Self = Self(8192);
4553 pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: Self = Self(16384);
4554 pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: Self = Self(32768);
4555 pub const RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: Self = Self(65536);
4556 pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: Self = Self(131072);
4557 pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: Self = Self(524288);
4558 pub const INDIRECT_BINDABLE_BIT_NV: Self = Self(262144);
4559 pub const RAY_TRACING_ALLOW_MOTION_BIT_NV: Self = Self(1048576);
4560 pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self = Self(2097152);
4561 pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: Self = Self(4194304);
4562 pub const COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: Self = Self(33554432);
4563 pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: Self = Self(67108864);
4564 pub const NO_PROTECTED_ACCESS_BIT_EXT: Self = Self(134217728);
4565 pub const PROTECTED_ACCESS_ONLY_BIT_EXT: Self = Self(1073741824);
4566 #[cfg(feature = "provisional")]
4567 pub const RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: Self = Self(268435456);
4568 pub const DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(536870912);
4569 pub const DISALLOW_OPACITY_MICROMAP_BIT_ARM: Self = Self(137438953472);
4570 pub const INSTRUMENT_SHADERS_BIT_ARM: Self = Self(549755813888);
4571 pub const CAPTURE_DATA_BIT_KHR: Self = Self(2147483648);
4572 pub const INDIRECT_BINDABLE_BIT_EXT: Self = Self(274877906944);
4573 pub const PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: Self = Self(1099511627776);
4574 pub const RAY_TRACING_OPACITY_MICROMAP_BIT_KHR: Self = Self(16777216);
4575 pub const OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR: Self = Self(2199023255552);
4576 pub const _64_BIT_INDEXING_BIT_EXT: Self = Self(8796093022208);
4577}
4578
4579impl std::ops::BitOr for PipelineCreateFlagBits2 {
4580 type Output = Self;
4581 fn bitor(self, rhs: Self) -> Self {
4582 Self(self.0 | rhs.0)
4583 }
4584}
4585
4586impl std::ops::BitAnd for PipelineCreateFlagBits2 {
4587 type Output = Self;
4588 fn bitand(self, rhs: Self) -> Self {
4589 Self(self.0 & rhs.0)
4590 }
4591}
4592
4593impl std::ops::BitXor for PipelineCreateFlagBits2 {
4594 type Output = Self;
4595 fn bitxor(self, rhs: Self) -> Self {
4596 Self(self.0 ^ rhs.0)
4597 }
4598}
4599
4600impl std::ops::Not for PipelineCreateFlagBits2 {
4601 type Output = Self;
4602 fn not(self) -> Self {
4603 Self(!self.0)
4604 }
4605}
4606
4607#[repr(transparent)]
4608#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4609pub struct PipelineShaderStageCreateFlagBits(pub u32);
4610impl PipelineShaderStageCreateFlagBits {
4611 pub const fn from_raw(value: u32) -> Self {
4612 Self(value)
4613 }
4614
4615 pub const fn as_raw(self) -> u32 {
4616 self.0
4617 }
4618
4619 pub const fn empty() -> Self {
4620 Self(0)
4621 }
4622
4623 pub const ALLOW_VARYING_SUBGROUP_SIZE_BIT: Self = Self(1);
4624 pub const REQUIRE_FULL_SUBGROUPS_BIT: Self = Self(2);
4625 pub const ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: Self = Self(1);
4626 pub const REQUIRE_FULL_SUBGROUPS_BIT_EXT: Self = Self(2);
4627}
4628
4629impl std::ops::BitOr for PipelineShaderStageCreateFlagBits {
4630 type Output = Self;
4631 fn bitor(self, rhs: Self) -> Self {
4632 Self(self.0 | rhs.0)
4633 }
4634}
4635
4636impl std::ops::BitAnd for PipelineShaderStageCreateFlagBits {
4637 type Output = Self;
4638 fn bitand(self, rhs: Self) -> Self {
4639 Self(self.0 & rhs.0)
4640 }
4641}
4642
4643impl std::ops::BitXor for PipelineShaderStageCreateFlagBits {
4644 type Output = Self;
4645 fn bitxor(self, rhs: Self) -> Self {
4646 Self(self.0 ^ rhs.0)
4647 }
4648}
4649
4650impl std::ops::Not for PipelineShaderStageCreateFlagBits {
4651 type Output = Self;
4652 fn not(self) -> Self {
4653 Self(!self.0)
4654 }
4655}
4656
4657#[repr(transparent)]
4658#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4659pub struct ColorComponentFlagBits(pub u32);
4660impl ColorComponentFlagBits {
4661 pub const fn from_raw(value: u32) -> Self {
4662 Self(value)
4663 }
4664
4665 pub const fn as_raw(self) -> u32 {
4666 self.0
4667 }
4668
4669 pub const fn empty() -> Self {
4670 Self(0)
4671 }
4672
4673 pub const R_BIT: Self = Self(1);
4674 pub const G_BIT: Self = Self(2);
4675 pub const B_BIT: Self = Self(4);
4676 pub const A_BIT: Self = Self(8);
4677}
4678
4679impl std::ops::BitOr for ColorComponentFlagBits {
4680 type Output = Self;
4681 fn bitor(self, rhs: Self) -> Self {
4682 Self(self.0 | rhs.0)
4683 }
4684}
4685
4686impl std::ops::BitAnd for ColorComponentFlagBits {
4687 type Output = Self;
4688 fn bitand(self, rhs: Self) -> Self {
4689 Self(self.0 & rhs.0)
4690 }
4691}
4692
4693impl std::ops::BitXor for ColorComponentFlagBits {
4694 type Output = Self;
4695 fn bitxor(self, rhs: Self) -> Self {
4696 Self(self.0 ^ rhs.0)
4697 }
4698}
4699
4700impl std::ops::Not for ColorComponentFlagBits {
4701 type Output = Self;
4702 fn not(self) -> Self {
4703 Self(!self.0)
4704 }
4705}
4706
4707#[repr(transparent)]
4708#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4709pub struct FenceCreateFlagBits(pub u32);
4710impl FenceCreateFlagBits {
4711 pub const fn from_raw(value: u32) -> Self {
4712 Self(value)
4713 }
4714
4715 pub const fn as_raw(self) -> u32 {
4716 self.0
4717 }
4718
4719 pub const fn empty() -> Self {
4720 Self(0)
4721 }
4722
4723 pub const SIGNALED_BIT: Self = Self(1);
4724}
4725
4726impl std::ops::BitOr for FenceCreateFlagBits {
4727 type Output = Self;
4728 fn bitor(self, rhs: Self) -> Self {
4729 Self(self.0 | rhs.0)
4730 }
4731}
4732
4733impl std::ops::BitAnd for FenceCreateFlagBits {
4734 type Output = Self;
4735 fn bitand(self, rhs: Self) -> Self {
4736 Self(self.0 & rhs.0)
4737 }
4738}
4739
4740impl std::ops::BitXor for FenceCreateFlagBits {
4741 type Output = Self;
4742 fn bitxor(self, rhs: Self) -> Self {
4743 Self(self.0 ^ rhs.0)
4744 }
4745}
4746
4747impl std::ops::Not for FenceCreateFlagBits {
4748 type Output = Self;
4749 fn not(self) -> Self {
4750 Self(!self.0)
4751 }
4752}
4753
4754#[repr(transparent)]
4755#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4756pub struct FormatFeatureFlagBits(pub u32);
4757impl FormatFeatureFlagBits {
4758 pub const fn from_raw(value: u32) -> Self {
4759 Self(value)
4760 }
4761
4762 pub const fn as_raw(self) -> u32 {
4763 self.0
4764 }
4765
4766 pub const fn empty() -> Self {
4767 Self(0)
4768 }
4769
4770 pub const SAMPLED_IMAGE_BIT: Self = Self(1);
4771 pub const STORAGE_IMAGE_BIT: Self = Self(2);
4772 pub const STORAGE_IMAGE_ATOMIC_BIT: Self = Self(4);
4773 pub const UNIFORM_TEXEL_BUFFER_BIT: Self = Self(8);
4774 pub const STORAGE_TEXEL_BUFFER_BIT: Self = Self(16);
4775 pub const STORAGE_TEXEL_BUFFER_ATOMIC_BIT: Self = Self(32);
4776 pub const VERTEX_BUFFER_BIT: Self = Self(64);
4777 pub const COLOR_ATTACHMENT_BIT: Self = Self(128);
4778 pub const COLOR_ATTACHMENT_BLEND_BIT: Self = Self(256);
4779 pub const DEPTH_STENCIL_ATTACHMENT_BIT: Self = Self(512);
4780 pub const BLIT_SRC_BIT: Self = Self(1024);
4781 pub const BLIT_DST_BIT: Self = Self(2048);
4782 pub const SAMPLED_IMAGE_FILTER_LINEAR_BIT: Self = Self(4096);
4783 pub const TRANSFER_SRC_BIT: Self = Self(16384);
4784 pub const TRANSFER_DST_BIT: Self = Self(32768);
4785 pub const MIDPOINT_CHROMA_SAMPLES_BIT: Self = Self(131072);
4786 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: Self = Self(262144);
4787 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: Self = Self(524288);
4788 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: Self = Self(1048576);
4789 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: Self =
4790 Self(2097152);
4791 pub const DISJOINT_BIT: Self = Self(4194304);
4792 pub const COSITED_CHROMA_SAMPLES_BIT: Self = Self(8388608);
4793 pub const SAMPLED_IMAGE_FILTER_MINMAX_BIT: Self = Self(65536);
4794 pub const SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG: Self = Self(8192);
4795 pub const VIDEO_DECODE_OUTPUT_BIT_KHR: Self = Self(33554432);
4796 pub const VIDEO_DECODE_DPB_BIT_KHR: Self = Self(67108864);
4797 pub const TRANSFER_SRC_BIT_KHR: Self = Self(16384);
4798 pub const TRANSFER_DST_BIT_KHR: Self = Self(32768);
4799 pub const SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT: Self = Self(65536);
4800 pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: Self = Self(536870912);
4801 pub const MIDPOINT_CHROMA_SAMPLES_BIT_KHR: Self = Self(131072);
4802 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: Self = Self(262144);
4803 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: Self =
4804 Self(524288);
4805 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: Self =
4806 Self(1048576);
4807 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: Self =
4808 Self(2097152);
4809 pub const DISJOINT_BIT_KHR: Self = Self(4194304);
4810 pub const COSITED_CHROMA_SAMPLES_BIT_KHR: Self = Self(8388608);
4811 pub const SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: Self = Self(8192);
4812 pub const FRAGMENT_DENSITY_MAP_BIT_EXT: Self = Self(16777216);
4813 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self = Self(1073741824);
4814 pub const VIDEO_ENCODE_INPUT_BIT_KHR: Self = Self(134217728);
4815 pub const VIDEO_ENCODE_DPB_BIT_KHR: Self = Self(268435456);
4816}
4817
4818impl std::ops::BitOr for FormatFeatureFlagBits {
4819 type Output = Self;
4820 fn bitor(self, rhs: Self) -> Self {
4821 Self(self.0 | rhs.0)
4822 }
4823}
4824
4825impl std::ops::BitAnd for FormatFeatureFlagBits {
4826 type Output = Self;
4827 fn bitand(self, rhs: Self) -> Self {
4828 Self(self.0 & rhs.0)
4829 }
4830}
4831
4832impl std::ops::BitXor for FormatFeatureFlagBits {
4833 type Output = Self;
4834 fn bitxor(self, rhs: Self) -> Self {
4835 Self(self.0 ^ rhs.0)
4836 }
4837}
4838
4839impl std::ops::Not for FormatFeatureFlagBits {
4840 type Output = Self;
4841 fn not(self) -> Self {
4842 Self(!self.0)
4843 }
4844}
4845
4846#[repr(transparent)]
4847#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4848pub struct QueryControlFlagBits(pub u32);
4849impl QueryControlFlagBits {
4850 pub const fn from_raw(value: u32) -> Self {
4851 Self(value)
4852 }
4853
4854 pub const fn as_raw(self) -> u32 {
4855 self.0
4856 }
4857
4858 pub const fn empty() -> Self {
4859 Self(0)
4860 }
4861
4862 pub const PRECISE_BIT: Self = Self(1);
4863}
4864
4865impl std::ops::BitOr for QueryControlFlagBits {
4866 type Output = Self;
4867 fn bitor(self, rhs: Self) -> Self {
4868 Self(self.0 | rhs.0)
4869 }
4870}
4871
4872impl std::ops::BitAnd for QueryControlFlagBits {
4873 type Output = Self;
4874 fn bitand(self, rhs: Self) -> Self {
4875 Self(self.0 & rhs.0)
4876 }
4877}
4878
4879impl std::ops::BitXor for QueryControlFlagBits {
4880 type Output = Self;
4881 fn bitxor(self, rhs: Self) -> Self {
4882 Self(self.0 ^ rhs.0)
4883 }
4884}
4885
4886impl std::ops::Not for QueryControlFlagBits {
4887 type Output = Self;
4888 fn not(self) -> Self {
4889 Self(!self.0)
4890 }
4891}
4892
4893#[repr(transparent)]
4894#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4895pub struct QueryResultFlagBits(pub u32);
4896impl QueryResultFlagBits {
4897 pub const fn from_raw(value: u32) -> Self {
4898 Self(value)
4899 }
4900
4901 pub const fn as_raw(self) -> u32 {
4902 self.0
4903 }
4904
4905 pub const fn empty() -> Self {
4906 Self(0)
4907 }
4908
4909 pub const _64_BIT: Self = Self(1);
4910 pub const WAIT_BIT: Self = Self(2);
4911 pub const WITH_AVAILABILITY_BIT: Self = Self(4);
4912 pub const PARTIAL_BIT: Self = Self(8);
4913 pub const WITH_STATUS_BIT_KHR: Self = Self(16);
4914}
4915
4916impl std::ops::BitOr for QueryResultFlagBits {
4917 type Output = Self;
4918 fn bitor(self, rhs: Self) -> Self {
4919 Self(self.0 | rhs.0)
4920 }
4921}
4922
4923impl std::ops::BitAnd for QueryResultFlagBits {
4924 type Output = Self;
4925 fn bitand(self, rhs: Self) -> Self {
4926 Self(self.0 & rhs.0)
4927 }
4928}
4929
4930impl std::ops::BitXor for QueryResultFlagBits {
4931 type Output = Self;
4932 fn bitxor(self, rhs: Self) -> Self {
4933 Self(self.0 ^ rhs.0)
4934 }
4935}
4936
4937impl std::ops::Not for QueryResultFlagBits {
4938 type Output = Self;
4939 fn not(self) -> Self {
4940 Self(!self.0)
4941 }
4942}
4943
4944#[repr(transparent)]
4945#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4946pub struct CommandBufferUsageFlagBits(pub u32);
4947impl CommandBufferUsageFlagBits {
4948 pub const fn from_raw(value: u32) -> Self {
4949 Self(value)
4950 }
4951
4952 pub const fn as_raw(self) -> u32 {
4953 self.0
4954 }
4955
4956 pub const fn empty() -> Self {
4957 Self(0)
4958 }
4959
4960 pub const ONE_TIME_SUBMIT_BIT: Self = Self(1);
4961 pub const RENDER_PASS_CONTINUE_BIT: Self = Self(2);
4962 pub const SIMULTANEOUS_USE_BIT: Self = Self(4);
4963}
4964
4965impl std::ops::BitOr for CommandBufferUsageFlagBits {
4966 type Output = Self;
4967 fn bitor(self, rhs: Self) -> Self {
4968 Self(self.0 | rhs.0)
4969 }
4970}
4971
4972impl std::ops::BitAnd for CommandBufferUsageFlagBits {
4973 type Output = Self;
4974 fn bitand(self, rhs: Self) -> Self {
4975 Self(self.0 & rhs.0)
4976 }
4977}
4978
4979impl std::ops::BitXor for CommandBufferUsageFlagBits {
4980 type Output = Self;
4981 fn bitxor(self, rhs: Self) -> Self {
4982 Self(self.0 ^ rhs.0)
4983 }
4984}
4985
4986impl std::ops::Not for CommandBufferUsageFlagBits {
4987 type Output = Self;
4988 fn not(self) -> Self {
4989 Self(!self.0)
4990 }
4991}
4992
4993#[repr(transparent)]
4994#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
4995pub struct QueryPipelineStatisticFlagBits(pub u32);
4996impl QueryPipelineStatisticFlagBits {
4997 pub const fn from_raw(value: u32) -> Self {
4998 Self(value)
4999 }
5000
5001 pub const fn as_raw(self) -> u32 {
5002 self.0
5003 }
5004
5005 pub const fn empty() -> Self {
5006 Self(0)
5007 }
5008
5009 pub const INPUT_ASSEMBLY_VERTICES_BIT: Self = Self(1);
5010 pub const INPUT_ASSEMBLY_PRIMITIVES_BIT: Self = Self(2);
5011 pub const VERTEX_SHADER_INVOCATIONS_BIT: Self = Self(4);
5012 pub const GEOMETRY_SHADER_INVOCATIONS_BIT: Self = Self(8);
5013 pub const GEOMETRY_SHADER_PRIMITIVES_BIT: Self = Self(16);
5014 pub const CLIPPING_INVOCATIONS_BIT: Self = Self(32);
5015 pub const CLIPPING_PRIMITIVES_BIT: Self = Self(64);
5016 pub const FRAGMENT_SHADER_INVOCATIONS_BIT: Self = Self(128);
5017 pub const TESSELLATION_CONTROL_SHADER_PATCHES_BIT: Self = Self(256);
5018 pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: Self = Self(512);
5019 pub const COMPUTE_SHADER_INVOCATIONS_BIT: Self = Self(1024);
5020 pub const TASK_SHADER_INVOCATIONS_BIT_EXT: Self = Self(2048);
5021 pub const MESH_SHADER_INVOCATIONS_BIT_EXT: Self = Self(4096);
5022 pub const CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI: Self = Self(8192);
5023}
5024
5025impl std::ops::BitOr for QueryPipelineStatisticFlagBits {
5026 type Output = Self;
5027 fn bitor(self, rhs: Self) -> Self {
5028 Self(self.0 | rhs.0)
5029 }
5030}
5031
5032impl std::ops::BitAnd for QueryPipelineStatisticFlagBits {
5033 type Output = Self;
5034 fn bitand(self, rhs: Self) -> Self {
5035 Self(self.0 & rhs.0)
5036 }
5037}
5038
5039impl std::ops::BitXor for QueryPipelineStatisticFlagBits {
5040 type Output = Self;
5041 fn bitxor(self, rhs: Self) -> Self {
5042 Self(self.0 ^ rhs.0)
5043 }
5044}
5045
5046impl std::ops::Not for QueryPipelineStatisticFlagBits {
5047 type Output = Self;
5048 fn not(self) -> Self {
5049 Self(!self.0)
5050 }
5051}
5052
5053#[repr(transparent)]
5054#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5055pub struct MemoryMapFlagBits(pub u32);
5056impl MemoryMapFlagBits {
5057 pub const fn from_raw(value: u32) -> Self {
5058 Self(value)
5059 }
5060
5061 pub const fn as_raw(self) -> u32 {
5062 self.0
5063 }
5064
5065 pub const fn empty() -> Self {
5066 Self(0)
5067 }
5068
5069 pub const PLACED_BIT_EXT: Self = Self(1);
5070}
5071
5072impl std::ops::BitOr for MemoryMapFlagBits {
5073 type Output = Self;
5074 fn bitor(self, rhs: Self) -> Self {
5075 Self(self.0 | rhs.0)
5076 }
5077}
5078
5079impl std::ops::BitAnd for MemoryMapFlagBits {
5080 type Output = Self;
5081 fn bitand(self, rhs: Self) -> Self {
5082 Self(self.0 & rhs.0)
5083 }
5084}
5085
5086impl std::ops::BitXor for MemoryMapFlagBits {
5087 type Output = Self;
5088 fn bitxor(self, rhs: Self) -> Self {
5089 Self(self.0 ^ rhs.0)
5090 }
5091}
5092
5093impl std::ops::Not for MemoryMapFlagBits {
5094 type Output = Self;
5095 fn not(self) -> Self {
5096 Self(!self.0)
5097 }
5098}
5099
5100#[repr(transparent)]
5101#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5102pub struct ImageAspectFlagBits(pub u32);
5103impl ImageAspectFlagBits {
5104 pub const fn from_raw(value: u32) -> Self {
5105 Self(value)
5106 }
5107
5108 pub const fn as_raw(self) -> u32 {
5109 self.0
5110 }
5111
5112 pub const fn empty() -> Self {
5113 Self(0)
5114 }
5115
5116 pub const COLOR_BIT: Self = Self(1);
5117 pub const DEPTH_BIT: Self = Self(2);
5118 pub const STENCIL_BIT: Self = Self(4);
5119 pub const METADATA_BIT: Self = Self(8);
5120 pub const PLANE_0_BIT: Self = Self(16);
5121 pub const PLANE_1_BIT: Self = Self(32);
5122 pub const PLANE_2_BIT: Self = Self(64);
5123 pub const NONE: Self = Self(0);
5124 pub const PLANE_0_BIT_KHR: Self = Self(16);
5125 pub const PLANE_1_BIT_KHR: Self = Self(32);
5126 pub const PLANE_2_BIT_KHR: Self = Self(64);
5127 pub const MEMORY_PLANE_0_BIT_EXT: Self = Self(128);
5128 pub const MEMORY_PLANE_1_BIT_EXT: Self = Self(256);
5129 pub const MEMORY_PLANE_2_BIT_EXT: Self = Self(512);
5130 pub const MEMORY_PLANE_3_BIT_EXT: Self = Self(1024);
5131 pub const NONE_KHR: Self = Self(0);
5132}
5133
5134impl std::ops::BitOr for ImageAspectFlagBits {
5135 type Output = Self;
5136 fn bitor(self, rhs: Self) -> Self {
5137 Self(self.0 | rhs.0)
5138 }
5139}
5140
5141impl std::ops::BitAnd for ImageAspectFlagBits {
5142 type Output = Self;
5143 fn bitand(self, rhs: Self) -> Self {
5144 Self(self.0 & rhs.0)
5145 }
5146}
5147
5148impl std::ops::BitXor for ImageAspectFlagBits {
5149 type Output = Self;
5150 fn bitxor(self, rhs: Self) -> Self {
5151 Self(self.0 ^ rhs.0)
5152 }
5153}
5154
5155impl std::ops::Not for ImageAspectFlagBits {
5156 type Output = Self;
5157 fn not(self) -> Self {
5158 Self(!self.0)
5159 }
5160}
5161
5162#[repr(transparent)]
5163#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5164pub struct SparseImageFormatFlagBits(pub u32);
5165impl SparseImageFormatFlagBits {
5166 pub const fn from_raw(value: u32) -> Self {
5167 Self(value)
5168 }
5169
5170 pub const fn as_raw(self) -> u32 {
5171 self.0
5172 }
5173
5174 pub const fn empty() -> Self {
5175 Self(0)
5176 }
5177
5178 pub const SINGLE_MIPTAIL_BIT: Self = Self(1);
5179 pub const ALIGNED_MIP_SIZE_BIT: Self = Self(2);
5180 pub const NONSTANDARD_BLOCK_SIZE_BIT: Self = Self(4);
5181}
5182
5183impl std::ops::BitOr for SparseImageFormatFlagBits {
5184 type Output = Self;
5185 fn bitor(self, rhs: Self) -> Self {
5186 Self(self.0 | rhs.0)
5187 }
5188}
5189
5190impl std::ops::BitAnd for SparseImageFormatFlagBits {
5191 type Output = Self;
5192 fn bitand(self, rhs: Self) -> Self {
5193 Self(self.0 & rhs.0)
5194 }
5195}
5196
5197impl std::ops::BitXor for SparseImageFormatFlagBits {
5198 type Output = Self;
5199 fn bitxor(self, rhs: Self) -> Self {
5200 Self(self.0 ^ rhs.0)
5201 }
5202}
5203
5204impl std::ops::Not for SparseImageFormatFlagBits {
5205 type Output = Self;
5206 fn not(self) -> Self {
5207 Self(!self.0)
5208 }
5209}
5210
5211#[repr(transparent)]
5212#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5213pub struct SparseMemoryBindFlagBits(pub u32);
5214impl SparseMemoryBindFlagBits {
5215 pub const fn from_raw(value: u32) -> Self {
5216 Self(value)
5217 }
5218
5219 pub const fn as_raw(self) -> u32 {
5220 self.0
5221 }
5222
5223 pub const fn empty() -> Self {
5224 Self(0)
5225 }
5226
5227 pub const METADATA_BIT: Self = Self(1);
5228}
5229
5230impl std::ops::BitOr for SparseMemoryBindFlagBits {
5231 type Output = Self;
5232 fn bitor(self, rhs: Self) -> Self {
5233 Self(self.0 | rhs.0)
5234 }
5235}
5236
5237impl std::ops::BitAnd for SparseMemoryBindFlagBits {
5238 type Output = Self;
5239 fn bitand(self, rhs: Self) -> Self {
5240 Self(self.0 & rhs.0)
5241 }
5242}
5243
5244impl std::ops::BitXor for SparseMemoryBindFlagBits {
5245 type Output = Self;
5246 fn bitxor(self, rhs: Self) -> Self {
5247 Self(self.0 ^ rhs.0)
5248 }
5249}
5250
5251impl std::ops::Not for SparseMemoryBindFlagBits {
5252 type Output = Self;
5253 fn not(self) -> Self {
5254 Self(!self.0)
5255 }
5256}
5257
5258#[repr(transparent)]
5259#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5260pub struct PipelineStageFlagBits(pub u32);
5261impl PipelineStageFlagBits {
5262 pub const fn from_raw(value: u32) -> Self {
5263 Self(value)
5264 }
5265
5266 pub const fn as_raw(self) -> u32 {
5267 self.0
5268 }
5269
5270 pub const fn empty() -> Self {
5271 Self(0)
5272 }
5273
5274 pub const TOP_OF_PIPE_BIT: Self = Self(1);
5275 pub const DRAW_INDIRECT_BIT: Self = Self(2);
5276 pub const VERTEX_INPUT_BIT: Self = Self(4);
5277 pub const VERTEX_SHADER_BIT: Self = Self(8);
5278 pub const TESSELLATION_CONTROL_SHADER_BIT: Self = Self(16);
5279 pub const TESSELLATION_EVALUATION_SHADER_BIT: Self = Self(32);
5280 pub const GEOMETRY_SHADER_BIT: Self = Self(64);
5281 pub const FRAGMENT_SHADER_BIT: Self = Self(128);
5282 pub const EARLY_FRAGMENT_TESTS_BIT: Self = Self(256);
5283 pub const LATE_FRAGMENT_TESTS_BIT: Self = Self(512);
5284 pub const COLOR_ATTACHMENT_OUTPUT_BIT: Self = Self(1024);
5285 pub const COMPUTE_SHADER_BIT: Self = Self(2048);
5286 pub const TRANSFER_BIT: Self = Self(4096);
5287 pub const BOTTOM_OF_PIPE_BIT: Self = Self(8192);
5288 pub const HOST_BIT: Self = Self(16384);
5289 pub const ALL_GRAPHICS_BIT: Self = Self(32768);
5290 pub const ALL_COMMANDS_BIT: Self = Self(65536);
5291 pub const NONE: Self = Self(0);
5292 pub const TRANSFORM_FEEDBACK_BIT_EXT: Self = Self(16777216);
5293 pub const CONDITIONAL_RENDERING_BIT_EXT: Self = Self(262144);
5294 pub const ACCELERATION_STRUCTURE_BUILD_BIT_KHR: Self = Self(33554432);
5295 pub const RAY_TRACING_SHADER_BIT_KHR: Self = Self(2097152);
5296 pub const SHADING_RATE_IMAGE_BIT_NV: Self = Self(4194304);
5297 pub const RAY_TRACING_SHADER_BIT_NV: Self = Self(2097152);
5298 pub const ACCELERATION_STRUCTURE_BUILD_BIT_NV: Self = Self(33554432);
5299 pub const TASK_SHADER_BIT_NV: Self = Self(524288);
5300 pub const MESH_SHADER_BIT_NV: Self = Self(1048576);
5301 pub const FRAGMENT_DENSITY_PROCESS_BIT_EXT: Self = Self(8388608);
5302 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self = Self(4194304);
5303 pub const COMMAND_PREPROCESS_BIT_NV: Self = Self(131072);
5304 pub const NONE_KHR: Self = Self(0);
5305 pub const TASK_SHADER_BIT_EXT: Self = Self(524288);
5306 pub const MESH_SHADER_BIT_EXT: Self = Self(1048576);
5307 pub const COMMAND_PREPROCESS_BIT_EXT: Self = Self(131072);
5308}
5309
5310impl std::ops::BitOr for PipelineStageFlagBits {
5311 type Output = Self;
5312 fn bitor(self, rhs: Self) -> Self {
5313 Self(self.0 | rhs.0)
5314 }
5315}
5316
5317impl std::ops::BitAnd for PipelineStageFlagBits {
5318 type Output = Self;
5319 fn bitand(self, rhs: Self) -> Self {
5320 Self(self.0 & rhs.0)
5321 }
5322}
5323
5324impl std::ops::BitXor for PipelineStageFlagBits {
5325 type Output = Self;
5326 fn bitxor(self, rhs: Self) -> Self {
5327 Self(self.0 ^ rhs.0)
5328 }
5329}
5330
5331impl std::ops::Not for PipelineStageFlagBits {
5332 type Output = Self;
5333 fn not(self) -> Self {
5334 Self(!self.0)
5335 }
5336}
5337
5338#[repr(transparent)]
5339#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5340pub struct CommandPoolCreateFlagBits(pub u32);
5341impl CommandPoolCreateFlagBits {
5342 pub const fn from_raw(value: u32) -> Self {
5343 Self(value)
5344 }
5345
5346 pub const fn as_raw(self) -> u32 {
5347 self.0
5348 }
5349
5350 pub const fn empty() -> Self {
5351 Self(0)
5352 }
5353
5354 pub const TRANSIENT_BIT: Self = Self(1);
5355 pub const RESET_COMMAND_BUFFER_BIT: Self = Self(2);
5356 pub const PROTECTED_BIT: Self = Self(4);
5357}
5358
5359impl std::ops::BitOr for CommandPoolCreateFlagBits {
5360 type Output = Self;
5361 fn bitor(self, rhs: Self) -> Self {
5362 Self(self.0 | rhs.0)
5363 }
5364}
5365
5366impl std::ops::BitAnd for CommandPoolCreateFlagBits {
5367 type Output = Self;
5368 fn bitand(self, rhs: Self) -> Self {
5369 Self(self.0 & rhs.0)
5370 }
5371}
5372
5373impl std::ops::BitXor for CommandPoolCreateFlagBits {
5374 type Output = Self;
5375 fn bitxor(self, rhs: Self) -> Self {
5376 Self(self.0 ^ rhs.0)
5377 }
5378}
5379
5380impl std::ops::Not for CommandPoolCreateFlagBits {
5381 type Output = Self;
5382 fn not(self) -> Self {
5383 Self(!self.0)
5384 }
5385}
5386
5387#[repr(transparent)]
5388#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5389pub struct CommandPoolResetFlagBits(pub u32);
5390impl CommandPoolResetFlagBits {
5391 pub const fn from_raw(value: u32) -> Self {
5392 Self(value)
5393 }
5394
5395 pub const fn as_raw(self) -> u32 {
5396 self.0
5397 }
5398
5399 pub const fn empty() -> Self {
5400 Self(0)
5401 }
5402
5403 pub const RELEASE_RESOURCES_BIT: Self = Self(1);
5404}
5405
5406impl std::ops::BitOr for CommandPoolResetFlagBits {
5407 type Output = Self;
5408 fn bitor(self, rhs: Self) -> Self {
5409 Self(self.0 | rhs.0)
5410 }
5411}
5412
5413impl std::ops::BitAnd for CommandPoolResetFlagBits {
5414 type Output = Self;
5415 fn bitand(self, rhs: Self) -> Self {
5416 Self(self.0 & rhs.0)
5417 }
5418}
5419
5420impl std::ops::BitXor for CommandPoolResetFlagBits {
5421 type Output = Self;
5422 fn bitxor(self, rhs: Self) -> Self {
5423 Self(self.0 ^ rhs.0)
5424 }
5425}
5426
5427impl std::ops::Not for CommandPoolResetFlagBits {
5428 type Output = Self;
5429 fn not(self) -> Self {
5430 Self(!self.0)
5431 }
5432}
5433
5434#[repr(transparent)]
5435#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5436pub struct CommandBufferResetFlagBits(pub u32);
5437impl CommandBufferResetFlagBits {
5438 pub const fn from_raw(value: u32) -> Self {
5439 Self(value)
5440 }
5441
5442 pub const fn as_raw(self) -> u32 {
5443 self.0
5444 }
5445
5446 pub const fn empty() -> Self {
5447 Self(0)
5448 }
5449
5450 pub const RELEASE_RESOURCES_BIT: Self = Self(1);
5451}
5452
5453impl std::ops::BitOr for CommandBufferResetFlagBits {
5454 type Output = Self;
5455 fn bitor(self, rhs: Self) -> Self {
5456 Self(self.0 | rhs.0)
5457 }
5458}
5459
5460impl std::ops::BitAnd for CommandBufferResetFlagBits {
5461 type Output = Self;
5462 fn bitand(self, rhs: Self) -> Self {
5463 Self(self.0 & rhs.0)
5464 }
5465}
5466
5467impl std::ops::BitXor for CommandBufferResetFlagBits {
5468 type Output = Self;
5469 fn bitxor(self, rhs: Self) -> Self {
5470 Self(self.0 ^ rhs.0)
5471 }
5472}
5473
5474impl std::ops::Not for CommandBufferResetFlagBits {
5475 type Output = Self;
5476 fn not(self) -> Self {
5477 Self(!self.0)
5478 }
5479}
5480
5481#[repr(transparent)]
5482#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5483pub struct SampleCountFlagBits(pub u32);
5484impl SampleCountFlagBits {
5485 pub const fn from_raw(value: u32) -> Self {
5486 Self(value)
5487 }
5488
5489 pub const fn as_raw(self) -> u32 {
5490 self.0
5491 }
5492
5493 pub const fn empty() -> Self {
5494 Self(0)
5495 }
5496
5497 pub const _1_BIT: Self = Self(1);
5498 pub const _2_BIT: Self = Self(2);
5499 pub const _4_BIT: Self = Self(4);
5500 pub const _8_BIT: Self = Self(8);
5501 pub const _16_BIT: Self = Self(16);
5502 pub const _32_BIT: Self = Self(32);
5503 pub const _64_BIT: Self = Self(64);
5504}
5505
5506impl std::ops::BitOr for SampleCountFlagBits {
5507 type Output = Self;
5508 fn bitor(self, rhs: Self) -> Self {
5509 Self(self.0 | rhs.0)
5510 }
5511}
5512
5513impl std::ops::BitAnd for SampleCountFlagBits {
5514 type Output = Self;
5515 fn bitand(self, rhs: Self) -> Self {
5516 Self(self.0 & rhs.0)
5517 }
5518}
5519
5520impl std::ops::BitXor for SampleCountFlagBits {
5521 type Output = Self;
5522 fn bitxor(self, rhs: Self) -> Self {
5523 Self(self.0 ^ rhs.0)
5524 }
5525}
5526
5527impl std::ops::Not for SampleCountFlagBits {
5528 type Output = Self;
5529 fn not(self) -> Self {
5530 Self(!self.0)
5531 }
5532}
5533
5534#[repr(transparent)]
5535#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5536pub struct AttachmentDescriptionFlagBits(pub u32);
5537impl AttachmentDescriptionFlagBits {
5538 pub const fn from_raw(value: u32) -> Self {
5539 Self(value)
5540 }
5541
5542 pub const fn as_raw(self) -> u32 {
5543 self.0
5544 }
5545
5546 pub const fn empty() -> Self {
5547 Self(0)
5548 }
5549
5550 pub const MAY_ALIAS_BIT: Self = Self(1);
5551 pub const RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: Self = Self(2);
5552 pub const RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: Self = Self(4);
5553}
5554
5555impl std::ops::BitOr for AttachmentDescriptionFlagBits {
5556 type Output = Self;
5557 fn bitor(self, rhs: Self) -> Self {
5558 Self(self.0 | rhs.0)
5559 }
5560}
5561
5562impl std::ops::BitAnd for AttachmentDescriptionFlagBits {
5563 type Output = Self;
5564 fn bitand(self, rhs: Self) -> Self {
5565 Self(self.0 & rhs.0)
5566 }
5567}
5568
5569impl std::ops::BitXor for AttachmentDescriptionFlagBits {
5570 type Output = Self;
5571 fn bitxor(self, rhs: Self) -> Self {
5572 Self(self.0 ^ rhs.0)
5573 }
5574}
5575
5576impl std::ops::Not for AttachmentDescriptionFlagBits {
5577 type Output = Self;
5578 fn not(self) -> Self {
5579 Self(!self.0)
5580 }
5581}
5582
5583#[repr(transparent)]
5584#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5585pub struct StencilFaceFlagBits(pub u32);
5586impl StencilFaceFlagBits {
5587 pub const fn from_raw(value: u32) -> Self {
5588 Self(value)
5589 }
5590
5591 pub const fn as_raw(self) -> u32 {
5592 self.0
5593 }
5594
5595 pub const fn empty() -> Self {
5596 Self(0)
5597 }
5598
5599 pub const FRONT_BIT: Self = Self(1);
5600 pub const BACK_BIT: Self = Self(2);
5601 pub const FRONT_AND_BACK: Self = Self(3);
5602 pub const STENCIL_FRONT_AND_BACK: Self = Self(3);
5603}
5604
5605impl std::ops::BitOr for StencilFaceFlagBits {
5606 type Output = Self;
5607 fn bitor(self, rhs: Self) -> Self {
5608 Self(self.0 | rhs.0)
5609 }
5610}
5611
5612impl std::ops::BitAnd for StencilFaceFlagBits {
5613 type Output = Self;
5614 fn bitand(self, rhs: Self) -> Self {
5615 Self(self.0 & rhs.0)
5616 }
5617}
5618
5619impl std::ops::BitXor for StencilFaceFlagBits {
5620 type Output = Self;
5621 fn bitxor(self, rhs: Self) -> Self {
5622 Self(self.0 ^ rhs.0)
5623 }
5624}
5625
5626impl std::ops::Not for StencilFaceFlagBits {
5627 type Output = Self;
5628 fn not(self) -> Self {
5629 Self(!self.0)
5630 }
5631}
5632
5633#[repr(transparent)]
5634#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5635pub struct DescriptorPoolCreateFlagBits(pub u32);
5636impl DescriptorPoolCreateFlagBits {
5637 pub const fn from_raw(value: u32) -> Self {
5638 Self(value)
5639 }
5640
5641 pub const fn as_raw(self) -> u32 {
5642 self.0
5643 }
5644
5645 pub const fn empty() -> Self {
5646 Self(0)
5647 }
5648
5649 pub const FREE_DESCRIPTOR_SET_BIT: Self = Self(1);
5650 pub const UPDATE_AFTER_BIND_BIT: Self = Self(2);
5651 pub const UPDATE_AFTER_BIND_BIT_EXT: Self = Self(2);
5652 pub const HOST_ONLY_BIT_VALVE: Self = Self(4);
5653 pub const HOST_ONLY_BIT_EXT: Self = Self(4);
5654 pub const ALLOW_OVERALLOCATION_SETS_BIT_NV: Self = Self(8);
5655 pub const ALLOW_OVERALLOCATION_POOLS_BIT_NV: Self = Self(16);
5656}
5657
5658impl std::ops::BitOr for DescriptorPoolCreateFlagBits {
5659 type Output = Self;
5660 fn bitor(self, rhs: Self) -> Self {
5661 Self(self.0 | rhs.0)
5662 }
5663}
5664
5665impl std::ops::BitAnd for DescriptorPoolCreateFlagBits {
5666 type Output = Self;
5667 fn bitand(self, rhs: Self) -> Self {
5668 Self(self.0 & rhs.0)
5669 }
5670}
5671
5672impl std::ops::BitXor for DescriptorPoolCreateFlagBits {
5673 type Output = Self;
5674 fn bitxor(self, rhs: Self) -> Self {
5675 Self(self.0 ^ rhs.0)
5676 }
5677}
5678
5679impl std::ops::Not for DescriptorPoolCreateFlagBits {
5680 type Output = Self;
5681 fn not(self) -> Self {
5682 Self(!self.0)
5683 }
5684}
5685
5686#[repr(transparent)]
5687#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5688pub struct DependencyFlagBits(pub u32);
5689impl DependencyFlagBits {
5690 pub const fn from_raw(value: u32) -> Self {
5691 Self(value)
5692 }
5693
5694 pub const fn as_raw(self) -> u32 {
5695 self.0
5696 }
5697
5698 pub const fn empty() -> Self {
5699 Self(0)
5700 }
5701
5702 pub const BY_REGION_BIT: Self = Self(1);
5703 pub const DEVICE_GROUP_BIT: Self = Self(4);
5704 pub const VIEW_LOCAL_BIT: Self = Self(2);
5705 pub const VIEW_LOCAL_BIT_KHR: Self = Self(2);
5706 pub const DEVICE_GROUP_BIT_KHR: Self = Self(4);
5707 pub const FEEDBACK_LOOP_BIT_EXT: Self = Self(8);
5708 pub const QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR: Self = Self(32);
5709 pub const ASYMMETRIC_EVENT_BIT_KHR: Self = Self(64);
5710}
5711
5712impl std::ops::BitOr for DependencyFlagBits {
5713 type Output = Self;
5714 fn bitor(self, rhs: Self) -> Self {
5715 Self(self.0 | rhs.0)
5716 }
5717}
5718
5719impl std::ops::BitAnd for DependencyFlagBits {
5720 type Output = Self;
5721 fn bitand(self, rhs: Self) -> Self {
5722 Self(self.0 & rhs.0)
5723 }
5724}
5725
5726impl std::ops::BitXor for DependencyFlagBits {
5727 type Output = Self;
5728 fn bitxor(self, rhs: Self) -> Self {
5729 Self(self.0 ^ rhs.0)
5730 }
5731}
5732
5733impl std::ops::Not for DependencyFlagBits {
5734 type Output = Self;
5735 fn not(self) -> Self {
5736 Self(!self.0)
5737 }
5738}
5739
5740#[repr(transparent)]
5741#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5742pub struct SemaphoreType(pub i32);
5743impl SemaphoreType {
5744 pub const fn from_raw(value: i32) -> Self {
5745 Self(value)
5746 }
5747
5748 pub const fn as_raw(self) -> i32 {
5749 self.0
5750 }
5751
5752 pub const fn empty() -> Self {
5753 Self(0)
5754 }
5755
5756 pub const BINARY: Self = Self(0);
5757 pub const TIMELINE: Self = Self(1);
5758 pub const BINARY_KHR: Self = Self(0);
5759 pub const TIMELINE_KHR: Self = Self(1);
5760}
5761
5762#[repr(transparent)]
5763#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5764pub struct SemaphoreWaitFlagBits(pub u32);
5765impl SemaphoreWaitFlagBits {
5766 pub const fn from_raw(value: u32) -> Self {
5767 Self(value)
5768 }
5769
5770 pub const fn as_raw(self) -> u32 {
5771 self.0
5772 }
5773
5774 pub const fn empty() -> Self {
5775 Self(0)
5776 }
5777
5778 pub const ANY_BIT: Self = Self(1);
5779 pub const ANY_BIT_KHR: Self = Self(1);
5780}
5781
5782impl std::ops::BitOr for SemaphoreWaitFlagBits {
5783 type Output = Self;
5784 fn bitor(self, rhs: Self) -> Self {
5785 Self(self.0 | rhs.0)
5786 }
5787}
5788
5789impl std::ops::BitAnd for SemaphoreWaitFlagBits {
5790 type Output = Self;
5791 fn bitand(self, rhs: Self) -> Self {
5792 Self(self.0 & rhs.0)
5793 }
5794}
5795
5796impl std::ops::BitXor for SemaphoreWaitFlagBits {
5797 type Output = Self;
5798 fn bitxor(self, rhs: Self) -> Self {
5799 Self(self.0 ^ rhs.0)
5800 }
5801}
5802
5803impl std::ops::Not for SemaphoreWaitFlagBits {
5804 type Output = Self;
5805 fn not(self) -> Self {
5806 Self(!self.0)
5807 }
5808}
5809
5810#[repr(transparent)]
5811#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5812pub struct PresentModeKHR(pub i32);
5813impl PresentModeKHR {
5814 pub const fn from_raw(value: i32) -> Self {
5815 Self(value)
5816 }
5817
5818 pub const fn as_raw(self) -> i32 {
5819 self.0
5820 }
5821
5822 pub const fn empty() -> Self {
5823 Self(0)
5824 }
5825
5826 pub const IMMEDIATE_KHR: Self = Self(0);
5827 pub const MAILBOX_KHR: Self = Self(1);
5828 pub const FIFO_KHR: Self = Self(2);
5829 pub const FIFO_RELAXED_KHR: Self = Self(3);
5830 pub const SHARED_DEMAND_REFRESH_KHR: Self = Self(1000111000);
5831 pub const SHARED_CONTINUOUS_REFRESH_KHR: Self = Self(1000111001);
5832 pub const FIFO_LATEST_READY_EXT: Self = Self(1000361000);
5833 pub const FIFO_LATEST_READY_KHR: Self = Self(1000361000);
5834}
5835
5836#[repr(transparent)]
5837#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5838pub struct ColorSpaceKHR(pub i32);
5839impl ColorSpaceKHR {
5840 pub const fn from_raw(value: i32) -> Self {
5841 Self(value)
5842 }
5843
5844 pub const fn as_raw(self) -> i32 {
5845 self.0
5846 }
5847
5848 pub const fn empty() -> Self {
5849 Self(0)
5850 }
5851
5852 pub const SRGB_NONLINEAR_KHR: Self = Self(0);
5853 pub const COLORSPACE_SRGB_NONLINEAR_KHR: Self = Self(0);
5854 pub const DISPLAY_P3_NONLINEAR_EXT: Self = Self(1000104001);
5855 pub const EXTENDED_SRGB_LINEAR_EXT: Self = Self(1000104002);
5856 pub const DISPLAY_P3_LINEAR_EXT: Self = Self(1000104003);
5857 pub const DCI_P3_NONLINEAR_EXT: Self = Self(1000104004);
5858 pub const BT709_LINEAR_EXT: Self = Self(1000104005);
5859 pub const BT709_NONLINEAR_EXT: Self = Self(1000104006);
5860 pub const BT2020_LINEAR_EXT: Self = Self(1000104007);
5861 pub const HDR10_ST2084_EXT: Self = Self(1000104008);
5862 pub const DOLBYVISION_EXT: Self = Self(1000104009);
5863 pub const HDR10_HLG_EXT: Self = Self(1000104010);
5864 pub const ADOBERGB_LINEAR_EXT: Self = Self(1000104011);
5865 pub const ADOBERGB_NONLINEAR_EXT: Self = Self(1000104012);
5866 pub const PASS_THROUGH_EXT: Self = Self(1000104013);
5867 pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = Self(1000104014);
5868 pub const DCI_P3_LINEAR_EXT: Self = Self(1000104003);
5869 pub const DISPLAY_NATIVE_AMD: Self = Self(1000213000);
5870}
5871
5872#[repr(transparent)]
5873#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5874pub struct DisplayPlaneAlphaFlagBitsKHR(pub u32);
5875impl DisplayPlaneAlphaFlagBitsKHR {
5876 pub const fn from_raw(value: u32) -> Self {
5877 Self(value)
5878 }
5879
5880 pub const fn as_raw(self) -> u32 {
5881 self.0
5882 }
5883
5884 pub const fn empty() -> Self {
5885 Self(0)
5886 }
5887
5888 pub const OPAQUE_BIT_KHR: Self = Self(1);
5889 pub const GLOBAL_BIT_KHR: Self = Self(2);
5890 pub const PER_PIXEL_BIT_KHR: Self = Self(4);
5891 pub const PER_PIXEL_PREMULTIPLIED_BIT_KHR: Self = Self(8);
5892}
5893
5894impl std::ops::BitOr for DisplayPlaneAlphaFlagBitsKHR {
5895 type Output = Self;
5896 fn bitor(self, rhs: Self) -> Self {
5897 Self(self.0 | rhs.0)
5898 }
5899}
5900
5901impl std::ops::BitAnd for DisplayPlaneAlphaFlagBitsKHR {
5902 type Output = Self;
5903 fn bitand(self, rhs: Self) -> Self {
5904 Self(self.0 & rhs.0)
5905 }
5906}
5907
5908impl std::ops::BitXor for DisplayPlaneAlphaFlagBitsKHR {
5909 type Output = Self;
5910 fn bitxor(self, rhs: Self) -> Self {
5911 Self(self.0 ^ rhs.0)
5912 }
5913}
5914
5915impl std::ops::Not for DisplayPlaneAlphaFlagBitsKHR {
5916 type Output = Self;
5917 fn not(self) -> Self {
5918 Self(!self.0)
5919 }
5920}
5921
5922#[repr(transparent)]
5923#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5924pub struct CompositeAlphaFlagBitsKHR(pub u32);
5925impl CompositeAlphaFlagBitsKHR {
5926 pub const fn from_raw(value: u32) -> Self {
5927 Self(value)
5928 }
5929
5930 pub const fn as_raw(self) -> u32 {
5931 self.0
5932 }
5933
5934 pub const fn empty() -> Self {
5935 Self(0)
5936 }
5937
5938 pub const OPAQUE_BIT_KHR: Self = Self(1);
5939 pub const PRE_MULTIPLIED_BIT_KHR: Self = Self(2);
5940 pub const POST_MULTIPLIED_BIT_KHR: Self = Self(4);
5941 pub const INHERIT_BIT_KHR: Self = Self(8);
5942}
5943
5944impl std::ops::BitOr for CompositeAlphaFlagBitsKHR {
5945 type Output = Self;
5946 fn bitor(self, rhs: Self) -> Self {
5947 Self(self.0 | rhs.0)
5948 }
5949}
5950
5951impl std::ops::BitAnd for CompositeAlphaFlagBitsKHR {
5952 type Output = Self;
5953 fn bitand(self, rhs: Self) -> Self {
5954 Self(self.0 & rhs.0)
5955 }
5956}
5957
5958impl std::ops::BitXor for CompositeAlphaFlagBitsKHR {
5959 type Output = Self;
5960 fn bitxor(self, rhs: Self) -> Self {
5961 Self(self.0 ^ rhs.0)
5962 }
5963}
5964
5965impl std::ops::Not for CompositeAlphaFlagBitsKHR {
5966 type Output = Self;
5967 fn not(self) -> Self {
5968 Self(!self.0)
5969 }
5970}
5971
5972#[repr(transparent)]
5973#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
5974pub struct SurfaceTransformFlagBitsKHR(pub u32);
5975impl SurfaceTransformFlagBitsKHR {
5976 pub const fn from_raw(value: u32) -> Self {
5977 Self(value)
5978 }
5979
5980 pub const fn as_raw(self) -> u32 {
5981 self.0
5982 }
5983
5984 pub const fn empty() -> Self {
5985 Self(0)
5986 }
5987
5988 pub const IDENTITY_BIT_KHR: Self = Self(1);
5989 pub const ROTATE_90_BIT_KHR: Self = Self(2);
5990 pub const ROTATE_180_BIT_KHR: Self = Self(4);
5991 pub const ROTATE_270_BIT_KHR: Self = Self(8);
5992 pub const HORIZONTAL_MIRROR_BIT_KHR: Self = Self(16);
5993 pub const HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: Self = Self(32);
5994 pub const HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: Self = Self(64);
5995 pub const HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: Self = Self(128);
5996 pub const INHERIT_BIT_KHR: Self = Self(256);
5997}
5998
5999impl std::ops::BitOr for SurfaceTransformFlagBitsKHR {
6000 type Output = Self;
6001 fn bitor(self, rhs: Self) -> Self {
6002 Self(self.0 | rhs.0)
6003 }
6004}
6005
6006impl std::ops::BitAnd for SurfaceTransformFlagBitsKHR {
6007 type Output = Self;
6008 fn bitand(self, rhs: Self) -> Self {
6009 Self(self.0 & rhs.0)
6010 }
6011}
6012
6013impl std::ops::BitXor for SurfaceTransformFlagBitsKHR {
6014 type Output = Self;
6015 fn bitxor(self, rhs: Self) -> Self {
6016 Self(self.0 ^ rhs.0)
6017 }
6018}
6019
6020impl std::ops::Not for SurfaceTransformFlagBitsKHR {
6021 type Output = Self;
6022 fn not(self) -> Self {
6023 Self(!self.0)
6024 }
6025}
6026
6027#[repr(transparent)]
6028#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6029pub struct DisplaySurfaceStereoTypeNV(pub i32);
6030impl DisplaySurfaceStereoTypeNV {
6031 pub const fn from_raw(value: i32) -> Self {
6032 Self(value)
6033 }
6034
6035 pub const fn as_raw(self) -> i32 {
6036 self.0
6037 }
6038
6039 pub const fn empty() -> Self {
6040 Self(0)
6041 }
6042
6043 pub const NONE_NV: Self = Self(0);
6044 pub const ONBOARD_DIN_NV: Self = Self(1);
6045 pub const HDMI_3D_NV: Self = Self(2);
6046 pub const INBAND_DISPLAYPORT_NV: Self = Self(3);
6047}
6048
6049#[repr(transparent)]
6050#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6051pub struct TimeDomainKHR(pub i32);
6052impl TimeDomainKHR {
6053 pub const fn from_raw(value: i32) -> Self {
6054 Self(value)
6055 }
6056
6057 pub const fn as_raw(self) -> i32 {
6058 self.0
6059 }
6060
6061 pub const fn empty() -> Self {
6062 Self(0)
6063 }
6064
6065 pub const DEVICE_KHR: Self = Self(0);
6066 pub const CLOCK_MONOTONIC_KHR: Self = Self(1);
6067 pub const CLOCK_MONOTONIC_RAW_KHR: Self = Self(2);
6068 pub const QUERY_PERFORMANCE_COUNTER_KHR: Self = Self(3);
6069 pub const DEVICE_EXT: Self = Self(0);
6070 pub const CLOCK_MONOTONIC_EXT: Self = Self(1);
6071 pub const CLOCK_MONOTONIC_RAW_EXT: Self = Self(2);
6072 pub const QUERY_PERFORMANCE_COUNTER_EXT: Self = Self(3);
6073 pub const PRESENT_STAGE_LOCAL_EXT: Self = Self(1000208000);
6074 pub const SWAPCHAIN_LOCAL_EXT: Self = Self(1000208001);
6075}
6076
6077#[repr(transparent)]
6078#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6079pub struct DebugReportFlagBitsEXT(pub u32);
6080impl DebugReportFlagBitsEXT {
6081 pub const fn from_raw(value: u32) -> Self {
6082 Self(value)
6083 }
6084
6085 pub const fn as_raw(self) -> u32 {
6086 self.0
6087 }
6088
6089 pub const fn empty() -> Self {
6090 Self(0)
6091 }
6092
6093 pub const INFORMATION_BIT_EXT: Self = Self(1);
6094 pub const WARNING_BIT_EXT: Self = Self(2);
6095 pub const PERFORMANCE_WARNING_BIT_EXT: Self = Self(4);
6096 pub const ERROR_BIT_EXT: Self = Self(8);
6097 pub const DEBUG_BIT_EXT: Self = Self(16);
6098}
6099
6100impl std::ops::BitOr for DebugReportFlagBitsEXT {
6101 type Output = Self;
6102 fn bitor(self, rhs: Self) -> Self {
6103 Self(self.0 | rhs.0)
6104 }
6105}
6106
6107impl std::ops::BitAnd for DebugReportFlagBitsEXT {
6108 type Output = Self;
6109 fn bitand(self, rhs: Self) -> Self {
6110 Self(self.0 & rhs.0)
6111 }
6112}
6113
6114impl std::ops::BitXor for DebugReportFlagBitsEXT {
6115 type Output = Self;
6116 fn bitxor(self, rhs: Self) -> Self {
6117 Self(self.0 ^ rhs.0)
6118 }
6119}
6120
6121impl std::ops::Not for DebugReportFlagBitsEXT {
6122 type Output = Self;
6123 fn not(self) -> Self {
6124 Self(!self.0)
6125 }
6126}
6127
6128#[repr(transparent)]
6129#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6130pub struct DebugReportObjectTypeEXT(pub i32);
6131impl DebugReportObjectTypeEXT {
6132 pub const fn from_raw(value: i32) -> Self {
6133 Self(value)
6134 }
6135
6136 pub const fn as_raw(self) -> i32 {
6137 self.0
6138 }
6139
6140 pub const fn empty() -> Self {
6141 Self(0)
6142 }
6143
6144 pub const UNKNOWN_EXT: Self = Self(0);
6145 pub const INSTANCE_EXT: Self = Self(1);
6146 pub const PHYSICAL_DEVICE_EXT: Self = Self(2);
6147 pub const DEVICE_EXT: Self = Self(3);
6148 pub const QUEUE_EXT: Self = Self(4);
6149 pub const SEMAPHORE_EXT: Self = Self(5);
6150 pub const COMMAND_BUFFER_EXT: Self = Self(6);
6151 pub const FENCE_EXT: Self = Self(7);
6152 pub const DEVICE_MEMORY_EXT: Self = Self(8);
6153 pub const BUFFER_EXT: Self = Self(9);
6154 pub const IMAGE_EXT: Self = Self(10);
6155 pub const EVENT_EXT: Self = Self(11);
6156 pub const QUERY_POOL_EXT: Self = Self(12);
6157 pub const BUFFER_VIEW_EXT: Self = Self(13);
6158 pub const IMAGE_VIEW_EXT: Self = Self(14);
6159 pub const SHADER_MODULE_EXT: Self = Self(15);
6160 pub const PIPELINE_CACHE_EXT: Self = Self(16);
6161 pub const PIPELINE_LAYOUT_EXT: Self = Self(17);
6162 pub const RENDER_PASS_EXT: Self = Self(18);
6163 pub const PIPELINE_EXT: Self = Self(19);
6164 pub const DESCRIPTOR_SET_LAYOUT_EXT: Self = Self(20);
6165 pub const SAMPLER_EXT: Self = Self(21);
6166 pub const DESCRIPTOR_POOL_EXT: Self = Self(22);
6167 pub const DESCRIPTOR_SET_EXT: Self = Self(23);
6168 pub const FRAMEBUFFER_EXT: Self = Self(24);
6169 pub const COMMAND_POOL_EXT: Self = Self(25);
6170 pub const SURFACE_KHR_EXT: Self = Self(26);
6171 pub const SWAPCHAIN_KHR_EXT: Self = Self(27);
6172 pub const DEBUG_REPORT_CALLBACK_EXT_EXT: Self = Self(28);
6173 pub const DEBUG_REPORT_EXT: Self = Self(28);
6174 pub const DISPLAY_KHR_EXT: Self = Self(29);
6175 pub const DISPLAY_MODE_KHR_EXT: Self = Self(30);
6176 pub const VALIDATION_CACHE_EXT_EXT: Self = Self(33);
6177 pub const VALIDATION_CACHE_EXT: Self = Self(33);
6178 pub const SAMPLER_YCBCR_CONVERSION_EXT: Self = Self(1000156000);
6179 pub const DESCRIPTOR_UPDATE_TEMPLATE_EXT: Self = Self(1000085000);
6180 pub const CU_MODULE_NVX_EXT: Self = Self(1000029000);
6181 pub const CU_FUNCTION_NVX_EXT: Self = Self(1000029001);
6182 pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT: Self = Self(1000085000);
6183 pub const ACCELERATION_STRUCTURE_KHR_EXT: Self = Self(1000150000);
6184 pub const SAMPLER_YCBCR_CONVERSION_KHR_EXT: Self = Self(1000156000);
6185 pub const ACCELERATION_STRUCTURE_NV_EXT: Self = Self(1000165000);
6186 #[cfg(feature = "provisional")]
6187 pub const CUDA_MODULE_NV_EXT: Self = Self(1000307000);
6188 #[cfg(feature = "provisional")]
6189 pub const CUDA_FUNCTION_NV_EXT: Self = Self(1000307001);
6190 #[cfg(feature = "platform-fuchsia")]
6191 pub const BUFFER_COLLECTION_FUCHSIA_EXT: Self = Self(1000366000);
6192}
6193
6194#[repr(transparent)]
6195#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6196pub struct DeviceMemoryReportEventTypeEXT(pub i32);
6197impl DeviceMemoryReportEventTypeEXT {
6198 pub const fn from_raw(value: i32) -> Self {
6199 Self(value)
6200 }
6201
6202 pub const fn as_raw(self) -> i32 {
6203 self.0
6204 }
6205
6206 pub const fn empty() -> Self {
6207 Self(0)
6208 }
6209
6210 pub const ALLOCATE_EXT: Self = Self(0);
6211 pub const FREE_EXT: Self = Self(1);
6212 pub const IMPORT_EXT: Self = Self(2);
6213 pub const UNIMPORT_EXT: Self = Self(3);
6214 pub const ALLOCATION_FAILED_EXT: Self = Self(4);
6215}
6216
6217#[repr(transparent)]
6218#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6219pub struct RasterizationOrderAMD(pub i32);
6220impl RasterizationOrderAMD {
6221 pub const fn from_raw(value: i32) -> Self {
6222 Self(value)
6223 }
6224
6225 pub const fn as_raw(self) -> i32 {
6226 self.0
6227 }
6228
6229 pub const fn empty() -> Self {
6230 Self(0)
6231 }
6232
6233 pub const STRICT_AMD: Self = Self(0);
6234 pub const RELAXED_AMD: Self = Self(1);
6235}
6236
6237#[repr(transparent)]
6238#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6239pub struct ExternalMemoryHandleTypeFlagBitsNV(pub u32);
6240impl ExternalMemoryHandleTypeFlagBitsNV {
6241 pub const fn from_raw(value: u32) -> Self {
6242 Self(value)
6243 }
6244
6245 pub const fn as_raw(self) -> u32 {
6246 self.0
6247 }
6248
6249 pub const fn empty() -> Self {
6250 Self(0)
6251 }
6252
6253 pub const OPAQUE_WIN32_BIT_NV: Self = Self(1);
6254 pub const OPAQUE_WIN32_KMT_BIT_NV: Self = Self(2);
6255 pub const D3D11_IMAGE_BIT_NV: Self = Self(4);
6256 pub const D3D11_IMAGE_KMT_BIT_NV: Self = Self(8);
6257}
6258
6259impl std::ops::BitOr for ExternalMemoryHandleTypeFlagBitsNV {
6260 type Output = Self;
6261 fn bitor(self, rhs: Self) -> Self {
6262 Self(self.0 | rhs.0)
6263 }
6264}
6265
6266impl std::ops::BitAnd for ExternalMemoryHandleTypeFlagBitsNV {
6267 type Output = Self;
6268 fn bitand(self, rhs: Self) -> Self {
6269 Self(self.0 & rhs.0)
6270 }
6271}
6272
6273impl std::ops::BitXor for ExternalMemoryHandleTypeFlagBitsNV {
6274 type Output = Self;
6275 fn bitxor(self, rhs: Self) -> Self {
6276 Self(self.0 ^ rhs.0)
6277 }
6278}
6279
6280impl std::ops::Not for ExternalMemoryHandleTypeFlagBitsNV {
6281 type Output = Self;
6282 fn not(self) -> Self {
6283 Self(!self.0)
6284 }
6285}
6286
6287#[repr(transparent)]
6288#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6289pub struct ExternalMemoryFeatureFlagBitsNV(pub u32);
6290impl ExternalMemoryFeatureFlagBitsNV {
6291 pub const fn from_raw(value: u32) -> Self {
6292 Self(value)
6293 }
6294
6295 pub const fn as_raw(self) -> u32 {
6296 self.0
6297 }
6298
6299 pub const fn empty() -> Self {
6300 Self(0)
6301 }
6302
6303 pub const DEDICATED_ONLY_BIT_NV: Self = Self(1);
6304 pub const EXPORTABLE_BIT_NV: Self = Self(2);
6305 pub const IMPORTABLE_BIT_NV: Self = Self(4);
6306}
6307
6308impl std::ops::BitOr for ExternalMemoryFeatureFlagBitsNV {
6309 type Output = Self;
6310 fn bitor(self, rhs: Self) -> Self {
6311 Self(self.0 | rhs.0)
6312 }
6313}
6314
6315impl std::ops::BitAnd for ExternalMemoryFeatureFlagBitsNV {
6316 type Output = Self;
6317 fn bitand(self, rhs: Self) -> Self {
6318 Self(self.0 & rhs.0)
6319 }
6320}
6321
6322impl std::ops::BitXor for ExternalMemoryFeatureFlagBitsNV {
6323 type Output = Self;
6324 fn bitxor(self, rhs: Self) -> Self {
6325 Self(self.0 ^ rhs.0)
6326 }
6327}
6328
6329impl std::ops::Not for ExternalMemoryFeatureFlagBitsNV {
6330 type Output = Self;
6331 fn not(self) -> Self {
6332 Self(!self.0)
6333 }
6334}
6335
6336#[repr(transparent)]
6337#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6338pub struct ClusterAccelerationStructureIndexFormatFlagBitsNV(pub u32);
6339impl ClusterAccelerationStructureIndexFormatFlagBitsNV {
6340 pub const fn from_raw(value: u32) -> Self {
6341 Self(value)
6342 }
6343
6344 pub const fn as_raw(self) -> u32 {
6345 self.0
6346 }
6347
6348 pub const fn empty() -> Self {
6349 Self(0)
6350 }
6351
6352 pub const _8BIT_NV: Self = Self(1);
6353 pub const _16BIT_NV: Self = Self(2);
6354 pub const _32BIT_NV: Self = Self(4);
6355}
6356
6357impl std::ops::BitOr for ClusterAccelerationStructureIndexFormatFlagBitsNV {
6358 type Output = Self;
6359 fn bitor(self, rhs: Self) -> Self {
6360 Self(self.0 | rhs.0)
6361 }
6362}
6363
6364impl std::ops::BitAnd for ClusterAccelerationStructureIndexFormatFlagBitsNV {
6365 type Output = Self;
6366 fn bitand(self, rhs: Self) -> Self {
6367 Self(self.0 & rhs.0)
6368 }
6369}
6370
6371impl std::ops::BitXor for ClusterAccelerationStructureIndexFormatFlagBitsNV {
6372 type Output = Self;
6373 fn bitxor(self, rhs: Self) -> Self {
6374 Self(self.0 ^ rhs.0)
6375 }
6376}
6377
6378impl std::ops::Not for ClusterAccelerationStructureIndexFormatFlagBitsNV {
6379 type Output = Self;
6380 fn not(self) -> Self {
6381 Self(!self.0)
6382 }
6383}
6384
6385#[repr(transparent)]
6386#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6387pub struct ClusterAccelerationStructureTypeNV(pub i32);
6388impl ClusterAccelerationStructureTypeNV {
6389 pub const fn from_raw(value: i32) -> Self {
6390 Self(value)
6391 }
6392
6393 pub const fn as_raw(self) -> i32 {
6394 self.0
6395 }
6396
6397 pub const fn empty() -> Self {
6398 Self(0)
6399 }
6400
6401 pub const CLUSTERS_BOTTOM_LEVEL_NV: Self = Self(0);
6402 pub const TRIANGLE_CLUSTER_NV: Self = Self(1);
6403 pub const TRIANGLE_CLUSTER_TEMPLATE_NV: Self = Self(2);
6404}
6405
6406#[repr(transparent)]
6407#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6408pub struct ClusterAccelerationStructureOpTypeNV(pub i32);
6409impl ClusterAccelerationStructureOpTypeNV {
6410 pub const fn from_raw(value: i32) -> Self {
6411 Self(value)
6412 }
6413
6414 pub const fn as_raw(self) -> i32 {
6415 self.0
6416 }
6417
6418 pub const fn empty() -> Self {
6419 Self(0)
6420 }
6421
6422 pub const MOVE_OBJECTS_NV: Self = Self(0);
6423 pub const BUILD_CLUSTERS_BOTTOM_LEVEL_NV: Self = Self(1);
6424 pub const BUILD_TRIANGLE_CLUSTER_NV: Self = Self(2);
6425 pub const BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV: Self = Self(3);
6426 pub const INSTANTIATE_TRIANGLE_CLUSTER_NV: Self = Self(4);
6427 pub const GET_CLUSTER_TEMPLATE_INDICES_NV: Self = Self(5);
6428}
6429
6430#[repr(transparent)]
6431#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6432pub struct ClusterAccelerationStructureOpModeNV(pub i32);
6433impl ClusterAccelerationStructureOpModeNV {
6434 pub const fn from_raw(value: i32) -> Self {
6435 Self(value)
6436 }
6437
6438 pub const fn as_raw(self) -> i32 {
6439 self.0
6440 }
6441
6442 pub const fn empty() -> Self {
6443 Self(0)
6444 }
6445
6446 pub const IMPLICIT_DESTINATIONS_NV: Self = Self(0);
6447 pub const EXPLICIT_DESTINATIONS_NV: Self = Self(1);
6448 pub const COMPUTE_SIZES_NV: Self = Self(2);
6449}
6450
6451#[repr(transparent)]
6452#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6453pub struct ClusterAccelerationStructureClusterFlagBitsNV(pub u32);
6454impl ClusterAccelerationStructureClusterFlagBitsNV {
6455 pub const fn from_raw(value: u32) -> Self {
6456 Self(value)
6457 }
6458
6459 pub const fn as_raw(self) -> u32 {
6460 self.0
6461 }
6462
6463 pub const fn empty() -> Self {
6464 Self(0)
6465 }
6466
6467 pub const ALLOW_DISABLE_OPACITY_MICROMAPS_NV: Self = Self(1);
6468}
6469
6470impl std::ops::BitOr for ClusterAccelerationStructureClusterFlagBitsNV {
6471 type Output = Self;
6472 fn bitor(self, rhs: Self) -> Self {
6473 Self(self.0 | rhs.0)
6474 }
6475}
6476
6477impl std::ops::BitAnd for ClusterAccelerationStructureClusterFlagBitsNV {
6478 type Output = Self;
6479 fn bitand(self, rhs: Self) -> Self {
6480 Self(self.0 & rhs.0)
6481 }
6482}
6483
6484impl std::ops::BitXor for ClusterAccelerationStructureClusterFlagBitsNV {
6485 type Output = Self;
6486 fn bitxor(self, rhs: Self) -> Self {
6487 Self(self.0 ^ rhs.0)
6488 }
6489}
6490
6491impl std::ops::Not for ClusterAccelerationStructureClusterFlagBitsNV {
6492 type Output = Self;
6493 fn not(self) -> Self {
6494 Self(!self.0)
6495 }
6496}
6497
6498#[repr(transparent)]
6499#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6500pub struct ClusterAccelerationStructureGeometryFlagBitsNV(pub u32);
6501impl ClusterAccelerationStructureGeometryFlagBitsNV {
6502 pub const fn from_raw(value: u32) -> Self {
6503 Self(value)
6504 }
6505
6506 pub const fn as_raw(self) -> u32 {
6507 self.0
6508 }
6509
6510 pub const fn empty() -> Self {
6511 Self(0)
6512 }
6513
6514 pub const CULL_DISABLE_BIT_NV: Self = Self(1);
6515 pub const NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV: Self = Self(2);
6516 pub const OPAQUE_BIT_NV: Self = Self(4);
6517}
6518
6519impl std::ops::BitOr for ClusterAccelerationStructureGeometryFlagBitsNV {
6520 type Output = Self;
6521 fn bitor(self, rhs: Self) -> Self {
6522 Self(self.0 | rhs.0)
6523 }
6524}
6525
6526impl std::ops::BitAnd for ClusterAccelerationStructureGeometryFlagBitsNV {
6527 type Output = Self;
6528 fn bitand(self, rhs: Self) -> Self {
6529 Self(self.0 & rhs.0)
6530 }
6531}
6532
6533impl std::ops::BitXor for ClusterAccelerationStructureGeometryFlagBitsNV {
6534 type Output = Self;
6535 fn bitxor(self, rhs: Self) -> Self {
6536 Self(self.0 ^ rhs.0)
6537 }
6538}
6539
6540impl std::ops::Not for ClusterAccelerationStructureGeometryFlagBitsNV {
6541 type Output = Self;
6542 fn not(self) -> Self {
6543 Self(!self.0)
6544 }
6545}
6546
6547#[repr(transparent)]
6548#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6549pub struct ClusterAccelerationStructureAddressResolutionFlagBitsNV(pub u32);
6550impl ClusterAccelerationStructureAddressResolutionFlagBitsNV {
6551 pub const fn from_raw(value: u32) -> Self {
6552 Self(value)
6553 }
6554
6555 pub const fn as_raw(self) -> u32 {
6556 self.0
6557 }
6558
6559 pub const fn empty() -> Self {
6560 Self(0)
6561 }
6562
6563 pub const NONE_NV: Self = Self(0);
6564 pub const INDIRECTED_DST_IMPLICIT_DATA_BIT_NV: Self = Self(1);
6565 pub const INDIRECTED_SCRATCH_DATA_BIT_NV: Self = Self(2);
6566 pub const INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV: Self = Self(4);
6567 pub const INDIRECTED_DST_SIZES_ARRAY_BIT_NV: Self = Self(8);
6568 pub const INDIRECTED_SRC_INFOS_ARRAY_BIT_NV: Self = Self(16);
6569 pub const INDIRECTED_SRC_INFOS_COUNT_BIT_NV: Self = Self(32);
6570}
6571
6572impl std::ops::BitOr for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
6573 type Output = Self;
6574 fn bitor(self, rhs: Self) -> Self {
6575 Self(self.0 | rhs.0)
6576 }
6577}
6578
6579impl std::ops::BitAnd for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
6580 type Output = Self;
6581 fn bitand(self, rhs: Self) -> Self {
6582 Self(self.0 & rhs.0)
6583 }
6584}
6585
6586impl std::ops::BitXor for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
6587 type Output = Self;
6588 fn bitxor(self, rhs: Self) -> Self {
6589 Self(self.0 ^ rhs.0)
6590 }
6591}
6592
6593impl std::ops::Not for ClusterAccelerationStructureAddressResolutionFlagBitsNV {
6594 type Output = Self;
6595 fn not(self) -> Self {
6596 Self(!self.0)
6597 }
6598}
6599
6600#[repr(transparent)]
6601#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6602pub struct ValidationCheckEXT(pub i32);
6603impl ValidationCheckEXT {
6604 pub const fn from_raw(value: i32) -> Self {
6605 Self(value)
6606 }
6607
6608 pub const fn as_raw(self) -> i32 {
6609 self.0
6610 }
6611
6612 pub const fn empty() -> Self {
6613 Self(0)
6614 }
6615
6616 pub const ALL_EXT: Self = Self(0);
6617 pub const SHADERS_EXT: Self = Self(1);
6618}
6619
6620#[repr(transparent)]
6621#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6622pub struct ValidationFeatureEnableEXT(pub i32);
6623impl ValidationFeatureEnableEXT {
6624 pub const fn from_raw(value: i32) -> Self {
6625 Self(value)
6626 }
6627
6628 pub const fn as_raw(self) -> i32 {
6629 self.0
6630 }
6631
6632 pub const fn empty() -> Self {
6633 Self(0)
6634 }
6635
6636 pub const GPU_ASSISTED_EXT: Self = Self(0);
6637 pub const GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT: Self = Self(1);
6638 pub const BEST_PRACTICES_EXT: Self = Self(2);
6639 pub const DEBUG_PRINTF_EXT: Self = Self(3);
6640 pub const SYNCHRONIZATION_VALIDATION_EXT: Self = Self(4);
6641}
6642
6643#[repr(transparent)]
6644#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6645pub struct ValidationFeatureDisableEXT(pub i32);
6646impl ValidationFeatureDisableEXT {
6647 pub const fn from_raw(value: i32) -> Self {
6648 Self(value)
6649 }
6650
6651 pub const fn as_raw(self) -> i32 {
6652 self.0
6653 }
6654
6655 pub const fn empty() -> Self {
6656 Self(0)
6657 }
6658
6659 pub const ALL_EXT: Self = Self(0);
6660 pub const SHADERS_EXT: Self = Self(1);
6661 pub const THREAD_SAFETY_EXT: Self = Self(2);
6662 pub const API_PARAMETERS_EXT: Self = Self(3);
6663 pub const OBJECT_LIFETIMES_EXT: Self = Self(4);
6664 pub const CORE_CHECKS_EXT: Self = Self(5);
6665 pub const UNIQUE_HANDLES_EXT: Self = Self(6);
6666 pub const SHADER_VALIDATION_CACHE_EXT: Self = Self(7);
6667}
6668
6669#[repr(transparent)]
6670#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6671pub struct LayerSettingTypeEXT(pub i32);
6672impl LayerSettingTypeEXT {
6673 pub const fn from_raw(value: i32) -> Self {
6674 Self(value)
6675 }
6676
6677 pub const fn as_raw(self) -> i32 {
6678 self.0
6679 }
6680
6681 pub const fn empty() -> Self {
6682 Self(0)
6683 }
6684
6685 pub const BOOL32_EXT: Self = Self(0);
6686 pub const INT32_EXT: Self = Self(1);
6687 pub const INT64_EXT: Self = Self(2);
6688 pub const UINT32_EXT: Self = Self(3);
6689 pub const UINT64_EXT: Self = Self(4);
6690 pub const FLOAT32_EXT: Self = Self(5);
6691 pub const FLOAT64_EXT: Self = Self(6);
6692 pub const STRING_EXT: Self = Self(7);
6693}
6694
6695#[repr(transparent)]
6696#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6697pub struct SubgroupFeatureFlagBits(pub u32);
6698impl SubgroupFeatureFlagBits {
6699 pub const fn from_raw(value: u32) -> Self {
6700 Self(value)
6701 }
6702
6703 pub const fn as_raw(self) -> u32 {
6704 self.0
6705 }
6706
6707 pub const fn empty() -> Self {
6708 Self(0)
6709 }
6710
6711 pub const BASIC_BIT: Self = Self(1);
6712 pub const VOTE_BIT: Self = Self(2);
6713 pub const ARITHMETIC_BIT: Self = Self(4);
6714 pub const BALLOT_BIT: Self = Self(8);
6715 pub const SHUFFLE_BIT: Self = Self(16);
6716 pub const SHUFFLE_RELATIVE_BIT: Self = Self(32);
6717 pub const CLUSTERED_BIT: Self = Self(64);
6718 pub const QUAD_BIT: Self = Self(128);
6719 pub const ROTATE_BIT: Self = Self(512);
6720 pub const ROTATE_CLUSTERED_BIT: Self = Self(1024);
6721 pub const PARTITIONED_BIT_NV: Self = Self(256);
6722 pub const ROTATE_BIT_KHR: Self = Self(512);
6723 pub const ROTATE_CLUSTERED_BIT_KHR: Self = Self(1024);
6724 pub const PARTITIONED_BIT_EXT: Self = Self(256);
6725}
6726
6727impl std::ops::BitOr for SubgroupFeatureFlagBits {
6728 type Output = Self;
6729 fn bitor(self, rhs: Self) -> Self {
6730 Self(self.0 | rhs.0)
6731 }
6732}
6733
6734impl std::ops::BitAnd for SubgroupFeatureFlagBits {
6735 type Output = Self;
6736 fn bitand(self, rhs: Self) -> Self {
6737 Self(self.0 & rhs.0)
6738 }
6739}
6740
6741impl std::ops::BitXor for SubgroupFeatureFlagBits {
6742 type Output = Self;
6743 fn bitxor(self, rhs: Self) -> Self {
6744 Self(self.0 ^ rhs.0)
6745 }
6746}
6747
6748impl std::ops::Not for SubgroupFeatureFlagBits {
6749 type Output = Self;
6750 fn not(self) -> Self {
6751 Self(!self.0)
6752 }
6753}
6754
6755#[repr(transparent)]
6756#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6757pub struct IndirectCommandsLayoutUsageFlagBitsNV(pub u32);
6758impl IndirectCommandsLayoutUsageFlagBitsNV {
6759 pub const fn from_raw(value: u32) -> Self {
6760 Self(value)
6761 }
6762
6763 pub const fn as_raw(self) -> u32 {
6764 self.0
6765 }
6766
6767 pub const fn empty() -> Self {
6768 Self(0)
6769 }
6770
6771 pub const EXPLICIT_PREPROCESS_BIT_NV: Self = Self(1);
6772 pub const INDEXED_SEQUENCES_BIT_NV: Self = Self(2);
6773 pub const UNORDERED_SEQUENCES_BIT_NV: Self = Self(4);
6774}
6775
6776impl std::ops::BitOr for IndirectCommandsLayoutUsageFlagBitsNV {
6777 type Output = Self;
6778 fn bitor(self, rhs: Self) -> Self {
6779 Self(self.0 | rhs.0)
6780 }
6781}
6782
6783impl std::ops::BitAnd for IndirectCommandsLayoutUsageFlagBitsNV {
6784 type Output = Self;
6785 fn bitand(self, rhs: Self) -> Self {
6786 Self(self.0 & rhs.0)
6787 }
6788}
6789
6790impl std::ops::BitXor for IndirectCommandsLayoutUsageFlagBitsNV {
6791 type Output = Self;
6792 fn bitxor(self, rhs: Self) -> Self {
6793 Self(self.0 ^ rhs.0)
6794 }
6795}
6796
6797impl std::ops::Not for IndirectCommandsLayoutUsageFlagBitsNV {
6798 type Output = Self;
6799 fn not(self) -> Self {
6800 Self(!self.0)
6801 }
6802}
6803
6804#[repr(transparent)]
6805#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6806pub struct IndirectStateFlagBitsNV(pub u32);
6807impl IndirectStateFlagBitsNV {
6808 pub const fn from_raw(value: u32) -> Self {
6809 Self(value)
6810 }
6811
6812 pub const fn as_raw(self) -> u32 {
6813 self.0
6814 }
6815
6816 pub const fn empty() -> Self {
6817 Self(0)
6818 }
6819
6820 pub const FLAG_FRONTFACE_BIT_NV: Self = Self(1);
6821}
6822
6823impl std::ops::BitOr for IndirectStateFlagBitsNV {
6824 type Output = Self;
6825 fn bitor(self, rhs: Self) -> Self {
6826 Self(self.0 | rhs.0)
6827 }
6828}
6829
6830impl std::ops::BitAnd for IndirectStateFlagBitsNV {
6831 type Output = Self;
6832 fn bitand(self, rhs: Self) -> Self {
6833 Self(self.0 & rhs.0)
6834 }
6835}
6836
6837impl std::ops::BitXor for IndirectStateFlagBitsNV {
6838 type Output = Self;
6839 fn bitxor(self, rhs: Self) -> Self {
6840 Self(self.0 ^ rhs.0)
6841 }
6842}
6843
6844impl std::ops::Not for IndirectStateFlagBitsNV {
6845 type Output = Self;
6846 fn not(self) -> Self {
6847 Self(!self.0)
6848 }
6849}
6850
6851#[repr(transparent)]
6852#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6853pub struct IndirectCommandsTokenTypeNV(pub i32);
6854impl IndirectCommandsTokenTypeNV {
6855 pub const fn from_raw(value: i32) -> Self {
6856 Self(value)
6857 }
6858
6859 pub const fn as_raw(self) -> i32 {
6860 self.0
6861 }
6862
6863 pub const fn empty() -> Self {
6864 Self(0)
6865 }
6866
6867 pub const SHADER_GROUP_NV: Self = Self(0);
6868 pub const STATE_FLAGS_NV: Self = Self(1);
6869 pub const INDEX_BUFFER_NV: Self = Self(2);
6870 pub const VERTEX_BUFFER_NV: Self = Self(3);
6871 pub const PUSH_CONSTANT_NV: Self = Self(4);
6872 pub const DRAW_INDEXED_NV: Self = Self(5);
6873 pub const DRAW_NV: Self = Self(6);
6874 pub const DRAW_TASKS_NV: Self = Self(7);
6875 pub const PUSH_DATA_NV: Self = Self(1000135000);
6876 pub const DRAW_MESH_TASKS_NV: Self = Self(1000328000);
6877 pub const PIPELINE_NV: Self = Self(1000428003);
6878 pub const DISPATCH_NV: Self = Self(1000428004);
6879}
6880
6881#[repr(transparent)]
6882#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6883pub struct PrivateDataSlotCreateFlagBits(pub u32);
6884impl PrivateDataSlotCreateFlagBits {
6885 pub const fn from_raw(value: u32) -> Self {
6886 Self(value)
6887 }
6888
6889 pub const fn as_raw(self) -> u32 {
6890 self.0
6891 }
6892
6893 pub const fn empty() -> Self {
6894 Self(0)
6895 }
6896
6897 pub const BASE_OBJECT_HANDLE_BIT_NV: Self = Self(1);
6898}
6899
6900impl std::ops::BitOr for PrivateDataSlotCreateFlagBits {
6901 type Output = Self;
6902 fn bitor(self, rhs: Self) -> Self {
6903 Self(self.0 | rhs.0)
6904 }
6905}
6906
6907impl std::ops::BitAnd for PrivateDataSlotCreateFlagBits {
6908 type Output = Self;
6909 fn bitand(self, rhs: Self) -> Self {
6910 Self(self.0 & rhs.0)
6911 }
6912}
6913
6914impl std::ops::BitXor for PrivateDataSlotCreateFlagBits {
6915 type Output = Self;
6916 fn bitxor(self, rhs: Self) -> Self {
6917 Self(self.0 ^ rhs.0)
6918 }
6919}
6920
6921impl std::ops::Not for PrivateDataSlotCreateFlagBits {
6922 type Output = Self;
6923 fn not(self) -> Self {
6924 Self(!self.0)
6925 }
6926}
6927
6928#[repr(transparent)]
6929#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6930pub struct DescriptorSetLayoutCreateFlagBits(pub u32);
6931impl DescriptorSetLayoutCreateFlagBits {
6932 pub const fn from_raw(value: u32) -> Self {
6933 Self(value)
6934 }
6935
6936 pub const fn as_raw(self) -> u32 {
6937 self.0
6938 }
6939
6940 pub const fn empty() -> Self {
6941 Self(0)
6942 }
6943
6944 pub const UPDATE_AFTER_BIND_POOL_BIT: Self = Self(2);
6945 pub const PUSH_DESCRIPTOR_BIT: Self = Self(1);
6946 pub const PUSH_DESCRIPTOR_BIT_KHR: Self = Self(1);
6947 pub const UPDATE_AFTER_BIND_POOL_BIT_EXT: Self = Self(2);
6948 pub const DESCRIPTOR_BUFFER_BIT_EXT: Self = Self(16);
6949 pub const EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT: Self = Self(32);
6950 pub const HOST_ONLY_POOL_BIT_VALVE: Self = Self(4);
6951 pub const INDIRECT_BINDABLE_BIT_NV: Self = Self(128);
6952 pub const HOST_ONLY_POOL_BIT_EXT: Self = Self(4);
6953 pub const PER_STAGE_BIT_NV: Self = Self(64);
6954}
6955
6956impl std::ops::BitOr for DescriptorSetLayoutCreateFlagBits {
6957 type Output = Self;
6958 fn bitor(self, rhs: Self) -> Self {
6959 Self(self.0 | rhs.0)
6960 }
6961}
6962
6963impl std::ops::BitAnd for DescriptorSetLayoutCreateFlagBits {
6964 type Output = Self;
6965 fn bitand(self, rhs: Self) -> Self {
6966 Self(self.0 & rhs.0)
6967 }
6968}
6969
6970impl std::ops::BitXor for DescriptorSetLayoutCreateFlagBits {
6971 type Output = Self;
6972 fn bitxor(self, rhs: Self) -> Self {
6973 Self(self.0 ^ rhs.0)
6974 }
6975}
6976
6977impl std::ops::Not for DescriptorSetLayoutCreateFlagBits {
6978 type Output = Self;
6979 fn not(self) -> Self {
6980 Self(!self.0)
6981 }
6982}
6983
6984#[repr(transparent)]
6985#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
6986pub struct ExternalMemoryHandleTypeFlagBits(pub u32);
6987impl ExternalMemoryHandleTypeFlagBits {
6988 pub const fn from_raw(value: u32) -> Self {
6989 Self(value)
6990 }
6991
6992 pub const fn as_raw(self) -> u32 {
6993 self.0
6994 }
6995
6996 pub const fn empty() -> Self {
6997 Self(0)
6998 }
6999
7000 pub const OPAQUE_FD_BIT: Self = Self(1);
7001 pub const OPAQUE_WIN32_BIT: Self = Self(2);
7002 pub const OPAQUE_WIN32_KMT_BIT: Self = Self(4);
7003 pub const D3D11_TEXTURE_BIT: Self = Self(8);
7004 pub const D3D11_TEXTURE_KMT_BIT: Self = Self(16);
7005 pub const D3D12_HEAP_BIT: Self = Self(32);
7006 pub const D3D12_RESOURCE_BIT: Self = Self(64);
7007 pub const OPAQUE_FD_BIT_KHR: Self = Self(1);
7008 pub const OPAQUE_WIN32_BIT_KHR: Self = Self(2);
7009 pub const OPAQUE_WIN32_KMT_BIT_KHR: Self = Self(4);
7010 pub const D3D11_TEXTURE_BIT_KHR: Self = Self(8);
7011 pub const D3D11_TEXTURE_KMT_BIT_KHR: Self = Self(16);
7012 pub const D3D12_HEAP_BIT_KHR: Self = Self(32);
7013 pub const D3D12_RESOURCE_BIT_KHR: Self = Self(64);
7014 pub const DMA_BUF_BIT_EXT: Self = Self(512);
7015 #[cfg(feature = "platform-android")]
7016 pub const ANDROID_HARDWARE_BUFFER_BIT_ANDROID: Self = Self(1024);
7017 pub const HOST_ALLOCATION_BIT_EXT: Self = Self(128);
7018 pub const HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: Self = Self(256);
7019 #[cfg(feature = "platform-fuchsia")]
7020 pub const ZIRCON_VMO_BIT_FUCHSIA: Self = Self(2048);
7021 pub const RDMA_ADDRESS_BIT_NV: Self = Self(4096);
7022 #[cfg(feature = "platform-ohos")]
7023 pub const OH_NATIVE_BUFFER_BIT_OHOS: Self = Self(32768);
7024 #[cfg(feature = "platform-screen")]
7025 pub const SCREEN_BUFFER_BIT_QNX: Self = Self(16384);
7026 #[cfg(feature = "platform-metal")]
7027 pub const MTLBUFFER_BIT_EXT: Self = Self(65536);
7028 #[cfg(feature = "platform-metal")]
7029 pub const MTLTEXTURE_BIT_EXT: Self = Self(131072);
7030 #[cfg(feature = "platform-metal")]
7031 pub const MTLHEAP_BIT_EXT: Self = Self(262144);
7032}
7033
7034impl std::ops::BitOr for ExternalMemoryHandleTypeFlagBits {
7035 type Output = Self;
7036 fn bitor(self, rhs: Self) -> Self {
7037 Self(self.0 | rhs.0)
7038 }
7039}
7040
7041impl std::ops::BitAnd for ExternalMemoryHandleTypeFlagBits {
7042 type Output = Self;
7043 fn bitand(self, rhs: Self) -> Self {
7044 Self(self.0 & rhs.0)
7045 }
7046}
7047
7048impl std::ops::BitXor for ExternalMemoryHandleTypeFlagBits {
7049 type Output = Self;
7050 fn bitxor(self, rhs: Self) -> Self {
7051 Self(self.0 ^ rhs.0)
7052 }
7053}
7054
7055impl std::ops::Not for ExternalMemoryHandleTypeFlagBits {
7056 type Output = Self;
7057 fn not(self) -> Self {
7058 Self(!self.0)
7059 }
7060}
7061
7062#[repr(transparent)]
7063#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7064pub struct ExternalMemoryFeatureFlagBits(pub u32);
7065impl ExternalMemoryFeatureFlagBits {
7066 pub const fn from_raw(value: u32) -> Self {
7067 Self(value)
7068 }
7069
7070 pub const fn as_raw(self) -> u32 {
7071 self.0
7072 }
7073
7074 pub const fn empty() -> Self {
7075 Self(0)
7076 }
7077
7078 pub const DEDICATED_ONLY_BIT: Self = Self(1);
7079 pub const EXPORTABLE_BIT: Self = Self(2);
7080 pub const IMPORTABLE_BIT: Self = Self(4);
7081 pub const DEDICATED_ONLY_BIT_KHR: Self = Self(1);
7082 pub const EXPORTABLE_BIT_KHR: Self = Self(2);
7083 pub const IMPORTABLE_BIT_KHR: Self = Self(4);
7084}
7085
7086impl std::ops::BitOr for ExternalMemoryFeatureFlagBits {
7087 type Output = Self;
7088 fn bitor(self, rhs: Self) -> Self {
7089 Self(self.0 | rhs.0)
7090 }
7091}
7092
7093impl std::ops::BitAnd for ExternalMemoryFeatureFlagBits {
7094 type Output = Self;
7095 fn bitand(self, rhs: Self) -> Self {
7096 Self(self.0 & rhs.0)
7097 }
7098}
7099
7100impl std::ops::BitXor for ExternalMemoryFeatureFlagBits {
7101 type Output = Self;
7102 fn bitxor(self, rhs: Self) -> Self {
7103 Self(self.0 ^ rhs.0)
7104 }
7105}
7106
7107impl std::ops::Not for ExternalMemoryFeatureFlagBits {
7108 type Output = Self;
7109 fn not(self) -> Self {
7110 Self(!self.0)
7111 }
7112}
7113
7114#[repr(transparent)]
7115#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7116pub struct ExternalSemaphoreHandleTypeFlagBits(pub u32);
7117impl ExternalSemaphoreHandleTypeFlagBits {
7118 pub const fn from_raw(value: u32) -> Self {
7119 Self(value)
7120 }
7121
7122 pub const fn as_raw(self) -> u32 {
7123 self.0
7124 }
7125
7126 pub const fn empty() -> Self {
7127 Self(0)
7128 }
7129
7130 pub const OPAQUE_FD_BIT: Self = Self(1);
7131 pub const OPAQUE_WIN32_BIT: Self = Self(2);
7132 pub const OPAQUE_WIN32_KMT_BIT: Self = Self(4);
7133 pub const D3D12_FENCE_BIT: Self = Self(8);
7134 pub const D3D11_FENCE_BIT: Self = Self(8);
7135 pub const SYNC_FD_BIT: Self = Self(16);
7136 pub const OPAQUE_FD_BIT_KHR: Self = Self(1);
7137 pub const OPAQUE_WIN32_BIT_KHR: Self = Self(2);
7138 pub const OPAQUE_WIN32_KMT_BIT_KHR: Self = Self(4);
7139 pub const D3D12_FENCE_BIT_KHR: Self = Self(8);
7140 pub const SYNC_FD_BIT_KHR: Self = Self(16);
7141 #[cfg(feature = "platform-fuchsia")]
7142 pub const ZIRCON_EVENT_BIT_FUCHSIA: Self = Self(128);
7143}
7144
7145impl std::ops::BitOr for ExternalSemaphoreHandleTypeFlagBits {
7146 type Output = Self;
7147 fn bitor(self, rhs: Self) -> Self {
7148 Self(self.0 | rhs.0)
7149 }
7150}
7151
7152impl std::ops::BitAnd for ExternalSemaphoreHandleTypeFlagBits {
7153 type Output = Self;
7154 fn bitand(self, rhs: Self) -> Self {
7155 Self(self.0 & rhs.0)
7156 }
7157}
7158
7159impl std::ops::BitXor for ExternalSemaphoreHandleTypeFlagBits {
7160 type Output = Self;
7161 fn bitxor(self, rhs: Self) -> Self {
7162 Self(self.0 ^ rhs.0)
7163 }
7164}
7165
7166impl std::ops::Not for ExternalSemaphoreHandleTypeFlagBits {
7167 type Output = Self;
7168 fn not(self) -> Self {
7169 Self(!self.0)
7170 }
7171}
7172
7173#[repr(transparent)]
7174#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7175pub struct ExternalSemaphoreFeatureFlagBits(pub u32);
7176impl ExternalSemaphoreFeatureFlagBits {
7177 pub const fn from_raw(value: u32) -> Self {
7178 Self(value)
7179 }
7180
7181 pub const fn as_raw(self) -> u32 {
7182 self.0
7183 }
7184
7185 pub const fn empty() -> Self {
7186 Self(0)
7187 }
7188
7189 pub const EXPORTABLE_BIT: Self = Self(1);
7190 pub const IMPORTABLE_BIT: Self = Self(2);
7191 pub const EXPORTABLE_BIT_KHR: Self = Self(1);
7192 pub const IMPORTABLE_BIT_KHR: Self = Self(2);
7193}
7194
7195impl std::ops::BitOr for ExternalSemaphoreFeatureFlagBits {
7196 type Output = Self;
7197 fn bitor(self, rhs: Self) -> Self {
7198 Self(self.0 | rhs.0)
7199 }
7200}
7201
7202impl std::ops::BitAnd for ExternalSemaphoreFeatureFlagBits {
7203 type Output = Self;
7204 fn bitand(self, rhs: Self) -> Self {
7205 Self(self.0 & rhs.0)
7206 }
7207}
7208
7209impl std::ops::BitXor for ExternalSemaphoreFeatureFlagBits {
7210 type Output = Self;
7211 fn bitxor(self, rhs: Self) -> Self {
7212 Self(self.0 ^ rhs.0)
7213 }
7214}
7215
7216impl std::ops::Not for ExternalSemaphoreFeatureFlagBits {
7217 type Output = Self;
7218 fn not(self) -> Self {
7219 Self(!self.0)
7220 }
7221}
7222
7223#[repr(transparent)]
7224#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7225pub struct SemaphoreImportFlagBits(pub u32);
7226impl SemaphoreImportFlagBits {
7227 pub const fn from_raw(value: u32) -> Self {
7228 Self(value)
7229 }
7230
7231 pub const fn as_raw(self) -> u32 {
7232 self.0
7233 }
7234
7235 pub const fn empty() -> Self {
7236 Self(0)
7237 }
7238
7239 pub const TEMPORARY_BIT: Self = Self(1);
7240 pub const TEMPORARY_BIT_KHR: Self = Self(1);
7241}
7242
7243impl std::ops::BitOr for SemaphoreImportFlagBits {
7244 type Output = Self;
7245 fn bitor(self, rhs: Self) -> Self {
7246 Self(self.0 | rhs.0)
7247 }
7248}
7249
7250impl std::ops::BitAnd for SemaphoreImportFlagBits {
7251 type Output = Self;
7252 fn bitand(self, rhs: Self) -> Self {
7253 Self(self.0 & rhs.0)
7254 }
7255}
7256
7257impl std::ops::BitXor for SemaphoreImportFlagBits {
7258 type Output = Self;
7259 fn bitxor(self, rhs: Self) -> Self {
7260 Self(self.0 ^ rhs.0)
7261 }
7262}
7263
7264impl std::ops::Not for SemaphoreImportFlagBits {
7265 type Output = Self;
7266 fn not(self) -> Self {
7267 Self(!self.0)
7268 }
7269}
7270
7271#[repr(transparent)]
7272#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7273pub struct ExternalFenceHandleTypeFlagBits(pub u32);
7274impl ExternalFenceHandleTypeFlagBits {
7275 pub const fn from_raw(value: u32) -> Self {
7276 Self(value)
7277 }
7278
7279 pub const fn as_raw(self) -> u32 {
7280 self.0
7281 }
7282
7283 pub const fn empty() -> Self {
7284 Self(0)
7285 }
7286
7287 pub const OPAQUE_FD_BIT: Self = Self(1);
7288 pub const OPAQUE_WIN32_BIT: Self = Self(2);
7289 pub const OPAQUE_WIN32_KMT_BIT: Self = Self(4);
7290 pub const SYNC_FD_BIT: Self = Self(8);
7291 pub const OPAQUE_FD_BIT_KHR: Self = Self(1);
7292 pub const OPAQUE_WIN32_BIT_KHR: Self = Self(2);
7293 pub const OPAQUE_WIN32_KMT_BIT_KHR: Self = Self(4);
7294 pub const SYNC_FD_BIT_KHR: Self = Self(8);
7295}
7296
7297impl std::ops::BitOr for ExternalFenceHandleTypeFlagBits {
7298 type Output = Self;
7299 fn bitor(self, rhs: Self) -> Self {
7300 Self(self.0 | rhs.0)
7301 }
7302}
7303
7304impl std::ops::BitAnd for ExternalFenceHandleTypeFlagBits {
7305 type Output = Self;
7306 fn bitand(self, rhs: Self) -> Self {
7307 Self(self.0 & rhs.0)
7308 }
7309}
7310
7311impl std::ops::BitXor for ExternalFenceHandleTypeFlagBits {
7312 type Output = Self;
7313 fn bitxor(self, rhs: Self) -> Self {
7314 Self(self.0 ^ rhs.0)
7315 }
7316}
7317
7318impl std::ops::Not for ExternalFenceHandleTypeFlagBits {
7319 type Output = Self;
7320 fn not(self) -> Self {
7321 Self(!self.0)
7322 }
7323}
7324
7325#[repr(transparent)]
7326#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7327pub struct ExternalFenceFeatureFlagBits(pub u32);
7328impl ExternalFenceFeatureFlagBits {
7329 pub const fn from_raw(value: u32) -> Self {
7330 Self(value)
7331 }
7332
7333 pub const fn as_raw(self) -> u32 {
7334 self.0
7335 }
7336
7337 pub const fn empty() -> Self {
7338 Self(0)
7339 }
7340
7341 pub const EXPORTABLE_BIT: Self = Self(1);
7342 pub const IMPORTABLE_BIT: Self = Self(2);
7343 pub const EXPORTABLE_BIT_KHR: Self = Self(1);
7344 pub const IMPORTABLE_BIT_KHR: Self = Self(2);
7345}
7346
7347impl std::ops::BitOr for ExternalFenceFeatureFlagBits {
7348 type Output = Self;
7349 fn bitor(self, rhs: Self) -> Self {
7350 Self(self.0 | rhs.0)
7351 }
7352}
7353
7354impl std::ops::BitAnd for ExternalFenceFeatureFlagBits {
7355 type Output = Self;
7356 fn bitand(self, rhs: Self) -> Self {
7357 Self(self.0 & rhs.0)
7358 }
7359}
7360
7361impl std::ops::BitXor for ExternalFenceFeatureFlagBits {
7362 type Output = Self;
7363 fn bitxor(self, rhs: Self) -> Self {
7364 Self(self.0 ^ rhs.0)
7365 }
7366}
7367
7368impl std::ops::Not for ExternalFenceFeatureFlagBits {
7369 type Output = Self;
7370 fn not(self) -> Self {
7371 Self(!self.0)
7372 }
7373}
7374
7375#[repr(transparent)]
7376#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7377pub struct FenceImportFlagBits(pub u32);
7378impl FenceImportFlagBits {
7379 pub const fn from_raw(value: u32) -> Self {
7380 Self(value)
7381 }
7382
7383 pub const fn as_raw(self) -> u32 {
7384 self.0
7385 }
7386
7387 pub const fn empty() -> Self {
7388 Self(0)
7389 }
7390
7391 pub const TEMPORARY_BIT: Self = Self(1);
7392 pub const TEMPORARY_BIT_KHR: Self = Self(1);
7393}
7394
7395impl std::ops::BitOr for FenceImportFlagBits {
7396 type Output = Self;
7397 fn bitor(self, rhs: Self) -> Self {
7398 Self(self.0 | rhs.0)
7399 }
7400}
7401
7402impl std::ops::BitAnd for FenceImportFlagBits {
7403 type Output = Self;
7404 fn bitand(self, rhs: Self) -> Self {
7405 Self(self.0 & rhs.0)
7406 }
7407}
7408
7409impl std::ops::BitXor for FenceImportFlagBits {
7410 type Output = Self;
7411 fn bitxor(self, rhs: Self) -> Self {
7412 Self(self.0 ^ rhs.0)
7413 }
7414}
7415
7416impl std::ops::Not for FenceImportFlagBits {
7417 type Output = Self;
7418 fn not(self) -> Self {
7419 Self(!self.0)
7420 }
7421}
7422
7423#[repr(transparent)]
7424#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7425pub struct SurfaceCounterFlagBitsEXT(pub u32);
7426impl SurfaceCounterFlagBitsEXT {
7427 pub const fn from_raw(value: u32) -> Self {
7428 Self(value)
7429 }
7430
7431 pub const fn as_raw(self) -> u32 {
7432 self.0
7433 }
7434
7435 pub const fn empty() -> Self {
7436 Self(0)
7437 }
7438
7439 pub const VBLANK_BIT_EXT: Self = Self(1);
7440 pub const VBLANK_EXT: Self = Self(1);
7441}
7442
7443impl std::ops::BitOr for SurfaceCounterFlagBitsEXT {
7444 type Output = Self;
7445 fn bitor(self, rhs: Self) -> Self {
7446 Self(self.0 | rhs.0)
7447 }
7448}
7449
7450impl std::ops::BitAnd for SurfaceCounterFlagBitsEXT {
7451 type Output = Self;
7452 fn bitand(self, rhs: Self) -> Self {
7453 Self(self.0 & rhs.0)
7454 }
7455}
7456
7457impl std::ops::BitXor for SurfaceCounterFlagBitsEXT {
7458 type Output = Self;
7459 fn bitxor(self, rhs: Self) -> Self {
7460 Self(self.0 ^ rhs.0)
7461 }
7462}
7463
7464impl std::ops::Not for SurfaceCounterFlagBitsEXT {
7465 type Output = Self;
7466 fn not(self) -> Self {
7467 Self(!self.0)
7468 }
7469}
7470
7471#[repr(transparent)]
7472#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7473pub struct DisplayPowerStateEXT(pub i32);
7474impl DisplayPowerStateEXT {
7475 pub const fn from_raw(value: i32) -> Self {
7476 Self(value)
7477 }
7478
7479 pub const fn as_raw(self) -> i32 {
7480 self.0
7481 }
7482
7483 pub const fn empty() -> Self {
7484 Self(0)
7485 }
7486
7487 pub const OFF_EXT: Self = Self(0);
7488 pub const SUSPEND_EXT: Self = Self(1);
7489 pub const ON_EXT: Self = Self(2);
7490}
7491
7492#[repr(transparent)]
7493#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7494pub struct DeviceEventTypeEXT(pub i32);
7495impl DeviceEventTypeEXT {
7496 pub const fn from_raw(value: i32) -> Self {
7497 Self(value)
7498 }
7499
7500 pub const fn as_raw(self) -> i32 {
7501 self.0
7502 }
7503
7504 pub const fn empty() -> Self {
7505 Self(0)
7506 }
7507
7508 pub const DISPLAY_HOTPLUG_EXT: Self = Self(0);
7509}
7510
7511#[repr(transparent)]
7512#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7513pub struct DisplayEventTypeEXT(pub i32);
7514impl DisplayEventTypeEXT {
7515 pub const fn from_raw(value: i32) -> Self {
7516 Self(value)
7517 }
7518
7519 pub const fn as_raw(self) -> i32 {
7520 self.0
7521 }
7522
7523 pub const fn empty() -> Self {
7524 Self(0)
7525 }
7526
7527 pub const FIRST_PIXEL_OUT_EXT: Self = Self(0);
7528}
7529
7530#[repr(transparent)]
7531#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7532pub struct PeerMemoryFeatureFlagBits(pub u32);
7533impl PeerMemoryFeatureFlagBits {
7534 pub const fn from_raw(value: u32) -> Self {
7535 Self(value)
7536 }
7537
7538 pub const fn as_raw(self) -> u32 {
7539 self.0
7540 }
7541
7542 pub const fn empty() -> Self {
7543 Self(0)
7544 }
7545
7546 pub const COPY_SRC_BIT: Self = Self(1);
7547 pub const COPY_DST_BIT: Self = Self(2);
7548 pub const GENERIC_SRC_BIT: Self = Self(4);
7549 pub const GENERIC_DST_BIT: Self = Self(8);
7550 pub const COPY_SRC_BIT_KHR: Self = Self(1);
7551 pub const COPY_DST_BIT_KHR: Self = Self(2);
7552 pub const GENERIC_SRC_BIT_KHR: Self = Self(4);
7553 pub const GENERIC_DST_BIT_KHR: Self = Self(8);
7554}
7555
7556impl std::ops::BitOr for PeerMemoryFeatureFlagBits {
7557 type Output = Self;
7558 fn bitor(self, rhs: Self) -> Self {
7559 Self(self.0 | rhs.0)
7560 }
7561}
7562
7563impl std::ops::BitAnd for PeerMemoryFeatureFlagBits {
7564 type Output = Self;
7565 fn bitand(self, rhs: Self) -> Self {
7566 Self(self.0 & rhs.0)
7567 }
7568}
7569
7570impl std::ops::BitXor for PeerMemoryFeatureFlagBits {
7571 type Output = Self;
7572 fn bitxor(self, rhs: Self) -> Self {
7573 Self(self.0 ^ rhs.0)
7574 }
7575}
7576
7577impl std::ops::Not for PeerMemoryFeatureFlagBits {
7578 type Output = Self;
7579 fn not(self) -> Self {
7580 Self(!self.0)
7581 }
7582}
7583
7584#[repr(transparent)]
7585#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7586pub struct MemoryAllocateFlagBits(pub u32);
7587impl MemoryAllocateFlagBits {
7588 pub const fn from_raw(value: u32) -> Self {
7589 Self(value)
7590 }
7591
7592 pub const fn as_raw(self) -> u32 {
7593 self.0
7594 }
7595
7596 pub const fn empty() -> Self {
7597 Self(0)
7598 }
7599
7600 pub const DEVICE_MASK_BIT: Self = Self(1);
7601 pub const DEVICE_ADDRESS_BIT: Self = Self(2);
7602 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: Self = Self(4);
7603 pub const DEVICE_MASK_BIT_KHR: Self = Self(1);
7604 pub const DEVICE_ADDRESS_BIT_KHR: Self = Self(2);
7605 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: Self = Self(4);
7606 pub const ZERO_INITIALIZE_BIT_EXT: Self = Self(8);
7607}
7608
7609impl std::ops::BitOr for MemoryAllocateFlagBits {
7610 type Output = Self;
7611 fn bitor(self, rhs: Self) -> Self {
7612 Self(self.0 | rhs.0)
7613 }
7614}
7615
7616impl std::ops::BitAnd for MemoryAllocateFlagBits {
7617 type Output = Self;
7618 fn bitand(self, rhs: Self) -> Self {
7619 Self(self.0 & rhs.0)
7620 }
7621}
7622
7623impl std::ops::BitXor for MemoryAllocateFlagBits {
7624 type Output = Self;
7625 fn bitxor(self, rhs: Self) -> Self {
7626 Self(self.0 ^ rhs.0)
7627 }
7628}
7629
7630impl std::ops::Not for MemoryAllocateFlagBits {
7631 type Output = Self;
7632 fn not(self) -> Self {
7633 Self(!self.0)
7634 }
7635}
7636
7637#[repr(transparent)]
7638#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7639pub struct DeviceGroupPresentModeFlagBitsKHR(pub u32);
7640impl DeviceGroupPresentModeFlagBitsKHR {
7641 pub const fn from_raw(value: u32) -> Self {
7642 Self(value)
7643 }
7644
7645 pub const fn as_raw(self) -> u32 {
7646 self.0
7647 }
7648
7649 pub const fn empty() -> Self {
7650 Self(0)
7651 }
7652
7653 pub const LOCAL_BIT_KHR: Self = Self(1);
7654 pub const REMOTE_BIT_KHR: Self = Self(2);
7655 pub const SUM_BIT_KHR: Self = Self(4);
7656 pub const LOCAL_MULTI_DEVICE_BIT_KHR: Self = Self(8);
7657}
7658
7659impl std::ops::BitOr for DeviceGroupPresentModeFlagBitsKHR {
7660 type Output = Self;
7661 fn bitor(self, rhs: Self) -> Self {
7662 Self(self.0 | rhs.0)
7663 }
7664}
7665
7666impl std::ops::BitAnd for DeviceGroupPresentModeFlagBitsKHR {
7667 type Output = Self;
7668 fn bitand(self, rhs: Self) -> Self {
7669 Self(self.0 & rhs.0)
7670 }
7671}
7672
7673impl std::ops::BitXor for DeviceGroupPresentModeFlagBitsKHR {
7674 type Output = Self;
7675 fn bitxor(self, rhs: Self) -> Self {
7676 Self(self.0 ^ rhs.0)
7677 }
7678}
7679
7680impl std::ops::Not for DeviceGroupPresentModeFlagBitsKHR {
7681 type Output = Self;
7682 fn not(self) -> Self {
7683 Self(!self.0)
7684 }
7685}
7686
7687#[repr(transparent)]
7688#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7689pub struct SwapchainCreateFlagBitsKHR(pub u32);
7690impl SwapchainCreateFlagBitsKHR {
7691 pub const fn from_raw(value: u32) -> Self {
7692 Self(value)
7693 }
7694
7695 pub const fn as_raw(self) -> u32 {
7696 self.0
7697 }
7698
7699 pub const fn empty() -> Self {
7700 Self(0)
7701 }
7702
7703 pub const SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: Self = Self(1);
7704 pub const PROTECTED_BIT_KHR: Self = Self(2);
7705 pub const MUTABLE_FORMAT_BIT_KHR: Self = Self(4);
7706 pub const PRESENT_TIMING_BIT_EXT: Self = Self(512);
7707 pub const DEFERRED_MEMORY_ALLOCATION_BIT_EXT: Self = Self(8);
7708 pub const PRESENT_ID_2_BIT_KHR: Self = Self(64);
7709 pub const PRESENT_WAIT_2_BIT_KHR: Self = Self(128);
7710 pub const DEFERRED_MEMORY_ALLOCATION_BIT_KHR: Self = Self(8);
7711 pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT: Self = Self(256);
7712}
7713
7714impl std::ops::BitOr for SwapchainCreateFlagBitsKHR {
7715 type Output = Self;
7716 fn bitor(self, rhs: Self) -> Self {
7717 Self(self.0 | rhs.0)
7718 }
7719}
7720
7721impl std::ops::BitAnd for SwapchainCreateFlagBitsKHR {
7722 type Output = Self;
7723 fn bitand(self, rhs: Self) -> Self {
7724 Self(self.0 & rhs.0)
7725 }
7726}
7727
7728impl std::ops::BitXor for SwapchainCreateFlagBitsKHR {
7729 type Output = Self;
7730 fn bitxor(self, rhs: Self) -> Self {
7731 Self(self.0 ^ rhs.0)
7732 }
7733}
7734
7735impl std::ops::Not for SwapchainCreateFlagBitsKHR {
7736 type Output = Self;
7737 fn not(self) -> Self {
7738 Self(!self.0)
7739 }
7740}
7741
7742#[repr(transparent)]
7743#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7744pub struct ViewportCoordinateSwizzleNV(pub i32);
7745impl ViewportCoordinateSwizzleNV {
7746 pub const fn from_raw(value: i32) -> Self {
7747 Self(value)
7748 }
7749
7750 pub const fn as_raw(self) -> i32 {
7751 self.0
7752 }
7753
7754 pub const fn empty() -> Self {
7755 Self(0)
7756 }
7757
7758 pub const POSITIVE_X_NV: Self = Self(0);
7759 pub const NEGATIVE_X_NV: Self = Self(1);
7760 pub const POSITIVE_Y_NV: Self = Self(2);
7761 pub const NEGATIVE_Y_NV: Self = Self(3);
7762 pub const POSITIVE_Z_NV: Self = Self(4);
7763 pub const NEGATIVE_Z_NV: Self = Self(5);
7764 pub const POSITIVE_W_NV: Self = Self(6);
7765 pub const NEGATIVE_W_NV: Self = Self(7);
7766}
7767
7768#[repr(transparent)]
7769#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7770pub struct DiscardRectangleModeEXT(pub i32);
7771impl DiscardRectangleModeEXT {
7772 pub const fn from_raw(value: i32) -> Self {
7773 Self(value)
7774 }
7775
7776 pub const fn as_raw(self) -> i32 {
7777 self.0
7778 }
7779
7780 pub const fn empty() -> Self {
7781 Self(0)
7782 }
7783
7784 pub const INCLUSIVE_EXT: Self = Self(0);
7785 pub const EXCLUSIVE_EXT: Self = Self(1);
7786}
7787
7788#[repr(transparent)]
7789#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7790pub struct SubpassDescriptionFlagBits(pub u32);
7791impl SubpassDescriptionFlagBits {
7792 pub const fn from_raw(value: u32) -> Self {
7793 Self(value)
7794 }
7795
7796 pub const fn as_raw(self) -> u32 {
7797 self.0
7798 }
7799
7800 pub const fn empty() -> Self {
7801 Self(0)
7802 }
7803
7804 pub const PER_VIEW_ATTRIBUTES_BIT_NVX: Self = Self(1);
7805 pub const PER_VIEW_POSITION_X_ONLY_BIT_NVX: Self = Self(2);
7806 pub const FRAGMENT_REGION_BIT_QCOM: Self = Self(4);
7807 pub const SHADER_RESOLVE_BIT_QCOM: Self = Self(8);
7808 pub const TILE_SHADING_APRON_BIT_QCOM: Self = Self(256);
7809 pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM: Self = Self(16);
7810 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: Self = Self(32);
7811 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: Self = Self(64);
7812 pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT: Self = Self(16);
7813 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: Self = Self(32);
7814 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: Self = Self(64);
7815 pub const ENABLE_LEGACY_DITHERING_BIT_EXT: Self = Self(128);
7816 pub const FRAGMENT_REGION_BIT_EXT: Self = Self(4);
7817 pub const CUSTOM_RESOLVE_BIT_EXT: Self = Self(8);
7818}
7819
7820impl std::ops::BitOr for SubpassDescriptionFlagBits {
7821 type Output = Self;
7822 fn bitor(self, rhs: Self) -> Self {
7823 Self(self.0 | rhs.0)
7824 }
7825}
7826
7827impl std::ops::BitAnd for SubpassDescriptionFlagBits {
7828 type Output = Self;
7829 fn bitand(self, rhs: Self) -> Self {
7830 Self(self.0 & rhs.0)
7831 }
7832}
7833
7834impl std::ops::BitXor for SubpassDescriptionFlagBits {
7835 type Output = Self;
7836 fn bitxor(self, rhs: Self) -> Self {
7837 Self(self.0 ^ rhs.0)
7838 }
7839}
7840
7841impl std::ops::Not for SubpassDescriptionFlagBits {
7842 type Output = Self;
7843 fn not(self) -> Self {
7844 Self(!self.0)
7845 }
7846}
7847
7848#[repr(transparent)]
7849#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7850pub struct PointClippingBehavior(pub i32);
7851impl PointClippingBehavior {
7852 pub const fn from_raw(value: i32) -> Self {
7853 Self(value)
7854 }
7855
7856 pub const fn as_raw(self) -> i32 {
7857 self.0
7858 }
7859
7860 pub const fn empty() -> Self {
7861 Self(0)
7862 }
7863
7864 pub const ALL_CLIP_PLANES: Self = Self(0);
7865 pub const USER_CLIP_PLANES_ONLY: Self = Self(1);
7866 pub const ALL_CLIP_PLANES_KHR: Self = Self(0);
7867 pub const USER_CLIP_PLANES_ONLY_KHR: Self = Self(1);
7868}
7869
7870#[repr(transparent)]
7871#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7872pub struct SamplerReductionMode(pub i32);
7873impl SamplerReductionMode {
7874 pub const fn from_raw(value: i32) -> Self {
7875 Self(value)
7876 }
7877
7878 pub const fn as_raw(self) -> i32 {
7879 self.0
7880 }
7881
7882 pub const fn empty() -> Self {
7883 Self(0)
7884 }
7885
7886 pub const WEIGHTED_AVERAGE: Self = Self(0);
7887 pub const MIN: Self = Self(1);
7888 pub const MAX: Self = Self(2);
7889 pub const WEIGHTED_AVERAGE_EXT: Self = Self(0);
7890 pub const MIN_EXT: Self = Self(1);
7891 pub const MAX_EXT: Self = Self(2);
7892 pub const WEIGHTED_AVERAGE_RANGECLAMP_QCOM: Self = Self(1000521000);
7893}
7894
7895#[repr(transparent)]
7896#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7897pub struct TessellationDomainOrigin(pub i32);
7898impl TessellationDomainOrigin {
7899 pub const fn from_raw(value: i32) -> Self {
7900 Self(value)
7901 }
7902
7903 pub const fn as_raw(self) -> i32 {
7904 self.0
7905 }
7906
7907 pub const fn empty() -> Self {
7908 Self(0)
7909 }
7910
7911 pub const UPPER_LEFT: Self = Self(0);
7912 pub const LOWER_LEFT: Self = Self(1);
7913 pub const UPPER_LEFT_KHR: Self = Self(0);
7914 pub const LOWER_LEFT_KHR: Self = Self(1);
7915}
7916
7917#[repr(transparent)]
7918#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7919pub struct SamplerYcbcrModelConversion(pub i32);
7920impl SamplerYcbcrModelConversion {
7921 pub const fn from_raw(value: i32) -> Self {
7922 Self(value)
7923 }
7924
7925 pub const fn as_raw(self) -> i32 {
7926 self.0
7927 }
7928
7929 pub const fn empty() -> Self {
7930 Self(0)
7931 }
7932
7933 pub const RGB_IDENTITY: Self = Self(0);
7934 pub const YCBCR_IDENTITY: Self = Self(1);
7935 pub const YCBCR_709: Self = Self(2);
7936 pub const YCBCR_601: Self = Self(3);
7937 pub const YCBCR_2020: Self = Self(4);
7938 pub const RGB_IDENTITY_KHR: Self = Self(0);
7939 pub const YCBCR_IDENTITY_KHR: Self = Self(1);
7940 pub const YCBCR_709_KHR: Self = Self(2);
7941 pub const YCBCR_601_KHR: Self = Self(3);
7942 pub const YCBCR_2020_KHR: Self = Self(4);
7943}
7944
7945#[repr(transparent)]
7946#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7947pub struct SamplerYcbcrRange(pub i32);
7948impl SamplerYcbcrRange {
7949 pub const fn from_raw(value: i32) -> Self {
7950 Self(value)
7951 }
7952
7953 pub const fn as_raw(self) -> i32 {
7954 self.0
7955 }
7956
7957 pub const fn empty() -> Self {
7958 Self(0)
7959 }
7960
7961 pub const ITU_FULL: Self = Self(0);
7962 pub const ITU_NARROW: Self = Self(1);
7963 pub const ITU_FULL_KHR: Self = Self(0);
7964 pub const ITU_NARROW_KHR: Self = Self(1);
7965}
7966
7967#[repr(transparent)]
7968#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7969pub struct ChromaLocation(pub i32);
7970impl ChromaLocation {
7971 pub const fn from_raw(value: i32) -> Self {
7972 Self(value)
7973 }
7974
7975 pub const fn as_raw(self) -> i32 {
7976 self.0
7977 }
7978
7979 pub const fn empty() -> Self {
7980 Self(0)
7981 }
7982
7983 pub const COSITED_EVEN: Self = Self(0);
7984 pub const MIDPOINT: Self = Self(1);
7985 pub const COSITED_EVEN_KHR: Self = Self(0);
7986 pub const MIDPOINT_KHR: Self = Self(1);
7987}
7988
7989#[repr(transparent)]
7990#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
7991pub struct BlendOverlapEXT(pub i32);
7992impl BlendOverlapEXT {
7993 pub const fn from_raw(value: i32) -> Self {
7994 Self(value)
7995 }
7996
7997 pub const fn as_raw(self) -> i32 {
7998 self.0
7999 }
8000
8001 pub const fn empty() -> Self {
8002 Self(0)
8003 }
8004
8005 pub const UNCORRELATED_EXT: Self = Self(0);
8006 pub const DISJOINT_EXT: Self = Self(1);
8007 pub const CONJOINT_EXT: Self = Self(2);
8008}
8009
8010#[repr(transparent)]
8011#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8012pub struct CoverageModulationModeNV(pub i32);
8013impl CoverageModulationModeNV {
8014 pub const fn from_raw(value: i32) -> Self {
8015 Self(value)
8016 }
8017
8018 pub const fn as_raw(self) -> i32 {
8019 self.0
8020 }
8021
8022 pub const fn empty() -> Self {
8023 Self(0)
8024 }
8025
8026 pub const NONE_NV: Self = Self(0);
8027 pub const RGB_NV: Self = Self(1);
8028 pub const ALPHA_NV: Self = Self(2);
8029 pub const RGBA_NV: Self = Self(3);
8030}
8031
8032#[repr(transparent)]
8033#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8034pub struct CoverageReductionModeNV(pub i32);
8035impl CoverageReductionModeNV {
8036 pub const fn from_raw(value: i32) -> Self {
8037 Self(value)
8038 }
8039
8040 pub const fn as_raw(self) -> i32 {
8041 self.0
8042 }
8043
8044 pub const fn empty() -> Self {
8045 Self(0)
8046 }
8047
8048 pub const MERGE_NV: Self = Self(0);
8049 pub const TRUNCATE_NV: Self = Self(1);
8050}
8051
8052#[repr(transparent)]
8053#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8054pub struct ValidationCacheHeaderVersionEXT(pub i32);
8055impl ValidationCacheHeaderVersionEXT {
8056 pub const fn from_raw(value: i32) -> Self {
8057 Self(value)
8058 }
8059
8060 pub const fn as_raw(self) -> i32 {
8061 self.0
8062 }
8063
8064 pub const fn empty() -> Self {
8065 Self(0)
8066 }
8067
8068 pub const ONE_EXT: Self = Self(1);
8069}
8070
8071#[repr(transparent)]
8072#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8073pub struct ShaderInfoTypeAMD(pub i32);
8074impl ShaderInfoTypeAMD {
8075 pub const fn from_raw(value: i32) -> Self {
8076 Self(value)
8077 }
8078
8079 pub const fn as_raw(self) -> i32 {
8080 self.0
8081 }
8082
8083 pub const fn empty() -> Self {
8084 Self(0)
8085 }
8086
8087 pub const STATISTICS_AMD: Self = Self(0);
8088 pub const BINARY_AMD: Self = Self(1);
8089 pub const DISASSEMBLY_AMD: Self = Self(2);
8090}
8091
8092#[repr(transparent)]
8093#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8094pub struct QueueGlobalPriority(pub i32);
8095impl QueueGlobalPriority {
8096 pub const fn from_raw(value: i32) -> Self {
8097 Self(value)
8098 }
8099
8100 pub const fn as_raw(self) -> i32 {
8101 self.0
8102 }
8103
8104 pub const fn empty() -> Self {
8105 Self(0)
8106 }
8107
8108 pub const LOW: Self = Self(128);
8109 pub const MEDIUM: Self = Self(256);
8110 pub const HIGH: Self = Self(512);
8111 pub const REALTIME: Self = Self(1024);
8112 pub const LOW_EXT: Self = Self(128);
8113 pub const MEDIUM_EXT: Self = Self(256);
8114 pub const HIGH_EXT: Self = Self(512);
8115 pub const REALTIME_EXT: Self = Self(1024);
8116 pub const LOW_KHR: Self = Self(128);
8117 pub const MEDIUM_KHR: Self = Self(256);
8118 pub const HIGH_KHR: Self = Self(512);
8119 pub const REALTIME_KHR: Self = Self(1024);
8120}
8121
8122#[repr(transparent)]
8123#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8124pub struct DebugUtilsMessageSeverityFlagBitsEXT(pub u32);
8125impl DebugUtilsMessageSeverityFlagBitsEXT {
8126 pub const fn from_raw(value: u32) -> Self {
8127 Self(value)
8128 }
8129
8130 pub const fn as_raw(self) -> u32 {
8131 self.0
8132 }
8133
8134 pub const fn empty() -> Self {
8135 Self(0)
8136 }
8137
8138 pub const VERBOSE_BIT_EXT: Self = Self(1);
8139 pub const INFO_BIT_EXT: Self = Self(16);
8140 pub const WARNING_BIT_EXT: Self = Self(256);
8141 pub const ERROR_BIT_EXT: Self = Self(4096);
8142}
8143
8144impl std::ops::BitOr for DebugUtilsMessageSeverityFlagBitsEXT {
8145 type Output = Self;
8146 fn bitor(self, rhs: Self) -> Self {
8147 Self(self.0 | rhs.0)
8148 }
8149}
8150
8151impl std::ops::BitAnd for DebugUtilsMessageSeverityFlagBitsEXT {
8152 type Output = Self;
8153 fn bitand(self, rhs: Self) -> Self {
8154 Self(self.0 & rhs.0)
8155 }
8156}
8157
8158impl std::ops::BitXor for DebugUtilsMessageSeverityFlagBitsEXT {
8159 type Output = Self;
8160 fn bitxor(self, rhs: Self) -> Self {
8161 Self(self.0 ^ rhs.0)
8162 }
8163}
8164
8165impl std::ops::Not for DebugUtilsMessageSeverityFlagBitsEXT {
8166 type Output = Self;
8167 fn not(self) -> Self {
8168 Self(!self.0)
8169 }
8170}
8171
8172#[repr(transparent)]
8173#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8174pub struct DebugUtilsMessageTypeFlagBitsEXT(pub u32);
8175impl DebugUtilsMessageTypeFlagBitsEXT {
8176 pub const fn from_raw(value: u32) -> Self {
8177 Self(value)
8178 }
8179
8180 pub const fn as_raw(self) -> u32 {
8181 self.0
8182 }
8183
8184 pub const fn empty() -> Self {
8185 Self(0)
8186 }
8187
8188 pub const GENERAL_BIT_EXT: Self = Self(1);
8189 pub const VALIDATION_BIT_EXT: Self = Self(2);
8190 pub const PERFORMANCE_BIT_EXT: Self = Self(4);
8191 pub const DEVICE_ADDRESS_BINDING_BIT_EXT: Self = Self(8);
8192}
8193
8194impl std::ops::BitOr for DebugUtilsMessageTypeFlagBitsEXT {
8195 type Output = Self;
8196 fn bitor(self, rhs: Self) -> Self {
8197 Self(self.0 | rhs.0)
8198 }
8199}
8200
8201impl std::ops::BitAnd for DebugUtilsMessageTypeFlagBitsEXT {
8202 type Output = Self;
8203 fn bitand(self, rhs: Self) -> Self {
8204 Self(self.0 & rhs.0)
8205 }
8206}
8207
8208impl std::ops::BitXor for DebugUtilsMessageTypeFlagBitsEXT {
8209 type Output = Self;
8210 fn bitxor(self, rhs: Self) -> Self {
8211 Self(self.0 ^ rhs.0)
8212 }
8213}
8214
8215impl std::ops::Not for DebugUtilsMessageTypeFlagBitsEXT {
8216 type Output = Self;
8217 fn not(self) -> Self {
8218 Self(!self.0)
8219 }
8220}
8221
8222#[repr(transparent)]
8223#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8224pub struct ConservativeRasterizationModeEXT(pub i32);
8225impl ConservativeRasterizationModeEXT {
8226 pub const fn from_raw(value: i32) -> Self {
8227 Self(value)
8228 }
8229
8230 pub const fn as_raw(self) -> i32 {
8231 self.0
8232 }
8233
8234 pub const fn empty() -> Self {
8235 Self(0)
8236 }
8237
8238 pub const DISABLED_EXT: Self = Self(0);
8239 pub const OVERESTIMATE_EXT: Self = Self(1);
8240 pub const UNDERESTIMATE_EXT: Self = Self(2);
8241}
8242
8243#[repr(transparent)]
8244#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8245pub struct DescriptorBindingFlagBits(pub u32);
8246impl DescriptorBindingFlagBits {
8247 pub const fn from_raw(value: u32) -> Self {
8248 Self(value)
8249 }
8250
8251 pub const fn as_raw(self) -> u32 {
8252 self.0
8253 }
8254
8255 pub const fn empty() -> Self {
8256 Self(0)
8257 }
8258
8259 pub const UPDATE_AFTER_BIND_BIT: Self = Self(1);
8260 pub const UPDATE_UNUSED_WHILE_PENDING_BIT: Self = Self(2);
8261 pub const PARTIALLY_BOUND_BIT: Self = Self(4);
8262 pub const VARIABLE_DESCRIPTOR_COUNT_BIT: Self = Self(8);
8263 pub const UPDATE_AFTER_BIND_BIT_EXT: Self = Self(1);
8264 pub const UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: Self = Self(2);
8265 pub const PARTIALLY_BOUND_BIT_EXT: Self = Self(4);
8266 pub const VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: Self = Self(8);
8267}
8268
8269impl std::ops::BitOr for DescriptorBindingFlagBits {
8270 type Output = Self;
8271 fn bitor(self, rhs: Self) -> Self {
8272 Self(self.0 | rhs.0)
8273 }
8274}
8275
8276impl std::ops::BitAnd for DescriptorBindingFlagBits {
8277 type Output = Self;
8278 fn bitand(self, rhs: Self) -> Self {
8279 Self(self.0 & rhs.0)
8280 }
8281}
8282
8283impl std::ops::BitXor for DescriptorBindingFlagBits {
8284 type Output = Self;
8285 fn bitxor(self, rhs: Self) -> Self {
8286 Self(self.0 ^ rhs.0)
8287 }
8288}
8289
8290impl std::ops::Not for DescriptorBindingFlagBits {
8291 type Output = Self;
8292 fn not(self) -> Self {
8293 Self(!self.0)
8294 }
8295}
8296
8297#[repr(transparent)]
8298#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8299pub struct VendorId(pub i32);
8300impl VendorId {
8301 pub const fn from_raw(value: i32) -> Self {
8302 Self(value)
8303 }
8304
8305 pub const fn as_raw(self) -> i32 {
8306 self.0
8307 }
8308
8309 pub const fn empty() -> Self {
8310 Self(0)
8311 }
8312
8313 pub const KHRONOS: Self = Self(65536);
8314 pub const VIV: Self = Self(65537);
8315 pub const VSI: Self = Self(65538);
8316 pub const KAZAN: Self = Self(65539);
8317 pub const CODEPLAY: Self = Self(65540);
8318 pub const MESA: Self = Self(65541);
8319 pub const POCL: Self = Self(65542);
8320 pub const MOBILEYE: Self = Self(65543);
8321 pub const APE: Self = Self(65544);
8322}
8323
8324#[repr(transparent)]
8325#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8326pub struct DriverId(pub i32);
8327impl DriverId {
8328 pub const fn from_raw(value: i32) -> Self {
8329 Self(value)
8330 }
8331
8332 pub const fn as_raw(self) -> i32 {
8333 self.0
8334 }
8335
8336 pub const fn empty() -> Self {
8337 Self(0)
8338 }
8339
8340 pub const AMD_PROPRIETARY: Self = Self(1);
8341 pub const AMD_OPEN_SOURCE: Self = Self(2);
8342 pub const MESA_RADV: Self = Self(3);
8343 pub const NVIDIA_PROPRIETARY: Self = Self(4);
8344 pub const INTEL_PROPRIETARY_WINDOWS: Self = Self(5);
8345 pub const INTEL_OPEN_SOURCE_MESA: Self = Self(6);
8346 pub const IMAGINATION_PROPRIETARY: Self = Self(7);
8347 pub const QUALCOMM_PROPRIETARY: Self = Self(8);
8348 pub const ARM_PROPRIETARY: Self = Self(9);
8349 pub const GOOGLE_SWIFTSHADER: Self = Self(10);
8350 pub const GGP_PROPRIETARY: Self = Self(11);
8351 pub const BROADCOM_PROPRIETARY: Self = Self(12);
8352 pub const MESA_LLVMPIPE: Self = Self(13);
8353 pub const MOLTENVK: Self = Self(14);
8354 pub const COREAVI_PROPRIETARY: Self = Self(15);
8355 pub const JUICE_PROPRIETARY: Self = Self(16);
8356 pub const VERISILICON_PROPRIETARY: Self = Self(17);
8357 pub const MESA_TURNIP: Self = Self(18);
8358 pub const MESA_V3DV: Self = Self(19);
8359 pub const MESA_PANVK: Self = Self(20);
8360 pub const SAMSUNG_PROPRIETARY: Self = Self(21);
8361 pub const MESA_VENUS: Self = Self(22);
8362 pub const MESA_DOZEN: Self = Self(23);
8363 pub const MESA_NVK: Self = Self(24);
8364 pub const IMAGINATION_OPEN_SOURCE_MESA: Self = Self(25);
8365 pub const MESA_HONEYKRISP: Self = Self(26);
8366 pub const VULKAN_SC_EMULATION_ON_VULKAN: Self = Self(27);
8367 pub const MESA_KOSMICKRISP: Self = Self(28);
8368 pub const MESA_GFXSTREAM: Self = Self(29);
8369 pub const APE_SOFT: Self = Self(30);
8370 pub const RESERVED_31: Self = Self(31);
8371 pub const AMD_PROPRIETARY_KHR: Self = Self(1);
8372 pub const AMD_OPEN_SOURCE_KHR: Self = Self(2);
8373 pub const MESA_RADV_KHR: Self = Self(3);
8374 pub const NVIDIA_PROPRIETARY_KHR: Self = Self(4);
8375 pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = Self(5);
8376 pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = Self(6);
8377 pub const IMAGINATION_PROPRIETARY_KHR: Self = Self(7);
8378 pub const QUALCOMM_PROPRIETARY_KHR: Self = Self(8);
8379 pub const ARM_PROPRIETARY_KHR: Self = Self(9);
8380 pub const GOOGLE_SWIFTSHADER_KHR: Self = Self(10);
8381 pub const GGP_PROPRIETARY_KHR: Self = Self(11);
8382 pub const BROADCOM_PROPRIETARY_KHR: Self = Self(12);
8383}
8384
8385#[repr(transparent)]
8386#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8387pub struct ConditionalRenderingFlagBitsEXT(pub u32);
8388impl ConditionalRenderingFlagBitsEXT {
8389 pub const fn from_raw(value: u32) -> Self {
8390 Self(value)
8391 }
8392
8393 pub const fn as_raw(self) -> u32 {
8394 self.0
8395 }
8396
8397 pub const fn empty() -> Self {
8398 Self(0)
8399 }
8400
8401 pub const INVERTED_BIT_EXT: Self = Self(1);
8402}
8403
8404impl std::ops::BitOr for ConditionalRenderingFlagBitsEXT {
8405 type Output = Self;
8406 fn bitor(self, rhs: Self) -> Self {
8407 Self(self.0 | rhs.0)
8408 }
8409}
8410
8411impl std::ops::BitAnd for ConditionalRenderingFlagBitsEXT {
8412 type Output = Self;
8413 fn bitand(self, rhs: Self) -> Self {
8414 Self(self.0 & rhs.0)
8415 }
8416}
8417
8418impl std::ops::BitXor for ConditionalRenderingFlagBitsEXT {
8419 type Output = Self;
8420 fn bitxor(self, rhs: Self) -> Self {
8421 Self(self.0 ^ rhs.0)
8422 }
8423}
8424
8425impl std::ops::Not for ConditionalRenderingFlagBitsEXT {
8426 type Output = Self;
8427 fn not(self) -> Self {
8428 Self(!self.0)
8429 }
8430}
8431
8432#[repr(transparent)]
8433#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8434pub struct ResolveModeFlagBits(pub u32);
8435impl ResolveModeFlagBits {
8436 pub const fn from_raw(value: u32) -> Self {
8437 Self(value)
8438 }
8439
8440 pub const fn as_raw(self) -> u32 {
8441 self.0
8442 }
8443
8444 pub const fn empty() -> Self {
8445 Self(0)
8446 }
8447
8448 pub const NONE: Self = Self(0);
8449 pub const SAMPLE_ZERO_BIT: Self = Self(1);
8450 pub const AVERAGE_BIT: Self = Self(2);
8451 pub const MIN_BIT: Self = Self(4);
8452 pub const MAX_BIT: Self = Self(8);
8453 pub const NONE_KHR: Self = Self(0);
8454 pub const SAMPLE_ZERO_BIT_KHR: Self = Self(1);
8455 pub const AVERAGE_BIT_KHR: Self = Self(2);
8456 pub const MIN_BIT_KHR: Self = Self(4);
8457 pub const MAX_BIT_KHR: Self = Self(8);
8458 #[cfg(feature = "platform-android")]
8459 pub const EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID: Self = Self(16);
8460 #[cfg(feature = "platform-android")]
8461 pub const EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID: Self = Self(16);
8462 pub const CUSTOM_BIT_EXT: Self = Self(32);
8463}
8464
8465impl std::ops::BitOr for ResolveModeFlagBits {
8466 type Output = Self;
8467 fn bitor(self, rhs: Self) -> Self {
8468 Self(self.0 | rhs.0)
8469 }
8470}
8471
8472impl std::ops::BitAnd for ResolveModeFlagBits {
8473 type Output = Self;
8474 fn bitand(self, rhs: Self) -> Self {
8475 Self(self.0 & rhs.0)
8476 }
8477}
8478
8479impl std::ops::BitXor for ResolveModeFlagBits {
8480 type Output = Self;
8481 fn bitxor(self, rhs: Self) -> Self {
8482 Self(self.0 ^ rhs.0)
8483 }
8484}
8485
8486impl std::ops::Not for ResolveModeFlagBits {
8487 type Output = Self;
8488 fn not(self) -> Self {
8489 Self(!self.0)
8490 }
8491}
8492
8493#[repr(transparent)]
8494#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8495pub struct ShadingRatePaletteEntryNV(pub i32);
8496impl ShadingRatePaletteEntryNV {
8497 pub const fn from_raw(value: i32) -> Self {
8498 Self(value)
8499 }
8500
8501 pub const fn as_raw(self) -> i32 {
8502 self.0
8503 }
8504
8505 pub const fn empty() -> Self {
8506 Self(0)
8507 }
8508
8509 pub const NO_INVOCATIONS_NV: Self = Self(0);
8510 pub const _16_INVOCATIONS_PER_PIXEL_NV: Self = Self(1);
8511 pub const _8_INVOCATIONS_PER_PIXEL_NV: Self = Self(2);
8512 pub const _4_INVOCATIONS_PER_PIXEL_NV: Self = Self(3);
8513 pub const _2_INVOCATIONS_PER_PIXEL_NV: Self = Self(4);
8514 pub const _1_INVOCATION_PER_PIXEL_NV: Self = Self(5);
8515 pub const _1_INVOCATION_PER_2X1_PIXELS_NV: Self = Self(6);
8516 pub const _1_INVOCATION_PER_1X2_PIXELS_NV: Self = Self(7);
8517 pub const _1_INVOCATION_PER_2X2_PIXELS_NV: Self = Self(8);
8518 pub const _1_INVOCATION_PER_4X2_PIXELS_NV: Self = Self(9);
8519 pub const _1_INVOCATION_PER_2X4_PIXELS_NV: Self = Self(10);
8520 pub const _1_INVOCATION_PER_4X4_PIXELS_NV: Self = Self(11);
8521}
8522
8523#[repr(transparent)]
8524#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8525pub struct CoarseSampleOrderTypeNV(pub i32);
8526impl CoarseSampleOrderTypeNV {
8527 pub const fn from_raw(value: i32) -> Self {
8528 Self(value)
8529 }
8530
8531 pub const fn as_raw(self) -> i32 {
8532 self.0
8533 }
8534
8535 pub const fn empty() -> Self {
8536 Self(0)
8537 }
8538
8539 pub const DEFAULT_NV: Self = Self(0);
8540 pub const CUSTOM_NV: Self = Self(1);
8541 pub const PIXEL_MAJOR_NV: Self = Self(2);
8542 pub const SAMPLE_MAJOR_NV: Self = Self(3);
8543}
8544
8545#[repr(transparent)]
8546#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8547pub struct GeometryInstanceFlagBitsKHR(pub u32);
8548impl GeometryInstanceFlagBitsKHR {
8549 pub const fn from_raw(value: u32) -> Self {
8550 Self(value)
8551 }
8552
8553 pub const fn as_raw(self) -> u32 {
8554 self.0
8555 }
8556
8557 pub const fn empty() -> Self {
8558 Self(0)
8559 }
8560
8561 pub const TRIANGLE_FACING_CULL_DISABLE_BIT_KHR: Self = Self(1);
8562 pub const TRIANGLE_FLIP_FACING_BIT_KHR: Self = Self(2);
8563 pub const FORCE_OPAQUE_BIT_KHR: Self = Self(4);
8564 pub const FORCE_NO_OPAQUE_BIT_KHR: Self = Self(8);
8565 pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR: Self = Self(2);
8566 pub const TRIANGLE_CULL_DISABLE_BIT_NV: Self = Self(1);
8567 pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV: Self = Self(2);
8568 pub const FORCE_OPAQUE_BIT_NV: Self = Self(4);
8569 pub const FORCE_NO_OPAQUE_BIT_NV: Self = Self(8);
8570 pub const FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT: Self = Self(16);
8571 pub const FORCE_OPACITY_MICROMAP_2_STATE_EXT: Self = Self(16);
8572 pub const DISABLE_OPACITY_MICROMAPS_BIT_EXT: Self = Self(32);
8573 pub const DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(32);
8574 pub const FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR: Self = Self(16);
8575 pub const DISABLE_OPACITY_MICROMAPS_BIT_KHR: Self = Self(32);
8576}
8577
8578impl std::ops::BitOr for GeometryInstanceFlagBitsKHR {
8579 type Output = Self;
8580 fn bitor(self, rhs: Self) -> Self {
8581 Self(self.0 | rhs.0)
8582 }
8583}
8584
8585impl std::ops::BitAnd for GeometryInstanceFlagBitsKHR {
8586 type Output = Self;
8587 fn bitand(self, rhs: Self) -> Self {
8588 Self(self.0 & rhs.0)
8589 }
8590}
8591
8592impl std::ops::BitXor for GeometryInstanceFlagBitsKHR {
8593 type Output = Self;
8594 fn bitxor(self, rhs: Self) -> Self {
8595 Self(self.0 ^ rhs.0)
8596 }
8597}
8598
8599impl std::ops::Not for GeometryInstanceFlagBitsKHR {
8600 type Output = Self;
8601 fn not(self) -> Self {
8602 Self(!self.0)
8603 }
8604}
8605
8606#[repr(transparent)]
8607#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8608pub struct GeometryFlagBitsKHR(pub u32);
8609impl GeometryFlagBitsKHR {
8610 pub const fn from_raw(value: u32) -> Self {
8611 Self(value)
8612 }
8613
8614 pub const fn as_raw(self) -> u32 {
8615 self.0
8616 }
8617
8618 pub const fn empty() -> Self {
8619 Self(0)
8620 }
8621
8622 pub const OPAQUE_BIT_KHR: Self = Self(1);
8623 pub const NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR: Self = Self(2);
8624 pub const OPAQUE_BIT_NV: Self = Self(1);
8625 pub const NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV: Self = Self(2);
8626}
8627
8628impl std::ops::BitOr for GeometryFlagBitsKHR {
8629 type Output = Self;
8630 fn bitor(self, rhs: Self) -> Self {
8631 Self(self.0 | rhs.0)
8632 }
8633}
8634
8635impl std::ops::BitAnd for GeometryFlagBitsKHR {
8636 type Output = Self;
8637 fn bitand(self, rhs: Self) -> Self {
8638 Self(self.0 & rhs.0)
8639 }
8640}
8641
8642impl std::ops::BitXor for GeometryFlagBitsKHR {
8643 type Output = Self;
8644 fn bitxor(self, rhs: Self) -> Self {
8645 Self(self.0 ^ rhs.0)
8646 }
8647}
8648
8649impl std::ops::Not for GeometryFlagBitsKHR {
8650 type Output = Self;
8651 fn not(self) -> Self {
8652 Self(!self.0)
8653 }
8654}
8655
8656#[repr(transparent)]
8657#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8658pub struct BuildAccelerationStructureFlagBitsKHR(pub u32);
8659impl BuildAccelerationStructureFlagBitsKHR {
8660 pub const fn from_raw(value: u32) -> Self {
8661 Self(value)
8662 }
8663
8664 pub const fn as_raw(self) -> u32 {
8665 self.0
8666 }
8667
8668 pub const fn empty() -> Self {
8669 Self(0)
8670 }
8671
8672 pub const ALLOW_UPDATE_BIT_KHR: Self = Self(1);
8673 pub const ALLOW_COMPACTION_BIT_KHR: Self = Self(2);
8674 pub const PREFER_FAST_TRACE_BIT_KHR: Self = Self(4);
8675 pub const PREFER_FAST_BUILD_BIT_KHR: Self = Self(8);
8676 pub const LOW_MEMORY_BIT_KHR: Self = Self(16);
8677 pub const ALLOW_UPDATE_BIT_NV: Self = Self(1);
8678 pub const ALLOW_COMPACTION_BIT_NV: Self = Self(2);
8679 pub const PREFER_FAST_TRACE_BIT_NV: Self = Self(4);
8680 pub const PREFER_FAST_BUILD_BIT_NV: Self = Self(8);
8681 pub const LOW_MEMORY_BIT_NV: Self = Self(16);
8682 pub const MOTION_BIT_NV: Self = Self(32);
8683 pub const ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT: Self = Self(64);
8684 pub const ALLOW_OPACITY_MICROMAP_UPDATE_EXT: Self = Self(64);
8685 pub const ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT: Self = Self(128);
8686 pub const ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(128);
8687 pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT: Self = Self(256);
8688 pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: Self = Self(256);
8689 #[cfg(feature = "provisional")]
8690 pub const ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV: Self = Self(512);
8691 #[cfg(feature = "provisional")]
8692 pub const ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV: Self = Self(512);
8693 pub const ALLOW_DATA_ACCESS_BIT_KHR: Self = Self(2048);
8694 pub const ALLOW_DATA_ACCESS_KHR: Self = Self(2048);
8695 pub const ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV: Self = Self(4096);
8696 pub const ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR: Self = Self(64);
8697 pub const ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR: Self = Self(128);
8698 pub const MICROMAP_LOSSY_BIT_KHR: Self = Self(1024);
8699}
8700
8701impl std::ops::BitOr for BuildAccelerationStructureFlagBitsKHR {
8702 type Output = Self;
8703 fn bitor(self, rhs: Self) -> Self {
8704 Self(self.0 | rhs.0)
8705 }
8706}
8707
8708impl std::ops::BitAnd for BuildAccelerationStructureFlagBitsKHR {
8709 type Output = Self;
8710 fn bitand(self, rhs: Self) -> Self {
8711 Self(self.0 & rhs.0)
8712 }
8713}
8714
8715impl std::ops::BitXor for BuildAccelerationStructureFlagBitsKHR {
8716 type Output = Self;
8717 fn bitxor(self, rhs: Self) -> Self {
8718 Self(self.0 ^ rhs.0)
8719 }
8720}
8721
8722impl std::ops::Not for BuildAccelerationStructureFlagBitsKHR {
8723 type Output = Self;
8724 fn not(self) -> Self {
8725 Self(!self.0)
8726 }
8727}
8728
8729#[repr(transparent)]
8730#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8731pub struct AccelerationStructureCreateFlagBitsKHR(pub u32);
8732impl AccelerationStructureCreateFlagBitsKHR {
8733 pub const fn from_raw(value: u32) -> Self {
8734 Self(value)
8735 }
8736
8737 pub const fn as_raw(self) -> u32 {
8738 self.0
8739 }
8740
8741 pub const fn empty() -> Self {
8742 Self(0)
8743 }
8744
8745 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: Self = Self(1);
8746 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: Self = Self(8);
8747 pub const MOTION_BIT_NV: Self = Self(4);
8748}
8749
8750impl std::ops::BitOr for AccelerationStructureCreateFlagBitsKHR {
8751 type Output = Self;
8752 fn bitor(self, rhs: Self) -> Self {
8753 Self(self.0 | rhs.0)
8754 }
8755}
8756
8757impl std::ops::BitAnd for AccelerationStructureCreateFlagBitsKHR {
8758 type Output = Self;
8759 fn bitand(self, rhs: Self) -> Self {
8760 Self(self.0 & rhs.0)
8761 }
8762}
8763
8764impl std::ops::BitXor for AccelerationStructureCreateFlagBitsKHR {
8765 type Output = Self;
8766 fn bitxor(self, rhs: Self) -> Self {
8767 Self(self.0 ^ rhs.0)
8768 }
8769}
8770
8771impl std::ops::Not for AccelerationStructureCreateFlagBitsKHR {
8772 type Output = Self;
8773 fn not(self) -> Self {
8774 Self(!self.0)
8775 }
8776}
8777
8778#[repr(transparent)]
8779#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8780pub struct CopyAccelerationStructureModeKHR(pub i32);
8781impl CopyAccelerationStructureModeKHR {
8782 pub const fn from_raw(value: i32) -> Self {
8783 Self(value)
8784 }
8785
8786 pub const fn as_raw(self) -> i32 {
8787 self.0
8788 }
8789
8790 pub const fn empty() -> Self {
8791 Self(0)
8792 }
8793
8794 pub const CLONE_KHR: Self = Self(0);
8795 pub const COMPACT_KHR: Self = Self(1);
8796 pub const SERIALIZE_KHR: Self = Self(2);
8797 pub const DESERIALIZE_KHR: Self = Self(3);
8798 pub const CLONE_NV: Self = Self(0);
8799 pub const COMPACT_NV: Self = Self(1);
8800}
8801
8802#[repr(transparent)]
8803#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8804pub struct BuildAccelerationStructureModeKHR(pub i32);
8805impl BuildAccelerationStructureModeKHR {
8806 pub const fn from_raw(value: i32) -> Self {
8807 Self(value)
8808 }
8809
8810 pub const fn as_raw(self) -> i32 {
8811 self.0
8812 }
8813
8814 pub const fn empty() -> Self {
8815 Self(0)
8816 }
8817
8818 pub const BUILD_KHR: Self = Self(0);
8819 pub const UPDATE_KHR: Self = Self(1);
8820}
8821
8822#[repr(transparent)]
8823#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8824pub struct AccelerationStructureTypeKHR(pub i32);
8825impl AccelerationStructureTypeKHR {
8826 pub const fn from_raw(value: i32) -> Self {
8827 Self(value)
8828 }
8829
8830 pub const fn as_raw(self) -> i32 {
8831 self.0
8832 }
8833
8834 pub const fn empty() -> Self {
8835 Self(0)
8836 }
8837
8838 pub const TOP_LEVEL_KHR: Self = Self(0);
8839 pub const BOTTOM_LEVEL_KHR: Self = Self(1);
8840 pub const GENERIC_KHR: Self = Self(2);
8841 pub const TOP_LEVEL_NV: Self = Self(0);
8842 pub const BOTTOM_LEVEL_NV: Self = Self(1);
8843 pub const OPACITY_MICROMAP_KHR: Self = Self(1000623000);
8844}
8845
8846#[repr(transparent)]
8847#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8848pub struct GeometryTypeKHR(pub i32);
8849impl GeometryTypeKHR {
8850 pub const fn from_raw(value: i32) -> Self {
8851 Self(value)
8852 }
8853
8854 pub const fn as_raw(self) -> i32 {
8855 self.0
8856 }
8857
8858 pub const fn empty() -> Self {
8859 Self(0)
8860 }
8861
8862 pub const TRIANGLES_KHR: Self = Self(0);
8863 pub const AABBS_KHR: Self = Self(1);
8864 pub const INSTANCES_KHR: Self = Self(2);
8865 pub const TRIANGLES_NV: Self = Self(0);
8866 pub const AABBS_NV: Self = Self(1);
8867 pub const SPHERES_NV: Self = Self(1000429004);
8868 pub const LINEAR_SWEPT_SPHERES_NV: Self = Self(1000429005);
8869 #[cfg(feature = "provisional")]
8870 pub const DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX: Self = Self(1000478000);
8871 pub const MICROMAP_KHR: Self = Self(1000623000);
8872}
8873
8874#[repr(transparent)]
8875#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8876pub struct AccelerationStructureMemoryRequirementsTypeNV(pub i32);
8877impl AccelerationStructureMemoryRequirementsTypeNV {
8878 pub const fn from_raw(value: i32) -> Self {
8879 Self(value)
8880 }
8881
8882 pub const fn as_raw(self) -> i32 {
8883 self.0
8884 }
8885
8886 pub const fn empty() -> Self {
8887 Self(0)
8888 }
8889
8890 pub const OBJECT_NV: Self = Self(0);
8891 pub const BUILD_SCRATCH_NV: Self = Self(1);
8892 pub const UPDATE_SCRATCH_NV: Self = Self(2);
8893}
8894
8895#[repr(transparent)]
8896#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8897pub struct AccelerationStructureBuildTypeKHR(pub i32);
8898impl AccelerationStructureBuildTypeKHR {
8899 pub const fn from_raw(value: i32) -> Self {
8900 Self(value)
8901 }
8902
8903 pub const fn as_raw(self) -> i32 {
8904 self.0
8905 }
8906
8907 pub const fn empty() -> Self {
8908 Self(0)
8909 }
8910
8911 pub const HOST_KHR: Self = Self(0);
8912 pub const DEVICE_KHR: Self = Self(1);
8913 pub const HOST_OR_DEVICE_KHR: Self = Self(2);
8914}
8915
8916#[repr(transparent)]
8917#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8918pub struct RayTracingShaderGroupTypeKHR(pub i32);
8919impl RayTracingShaderGroupTypeKHR {
8920 pub const fn from_raw(value: i32) -> Self {
8921 Self(value)
8922 }
8923
8924 pub const fn as_raw(self) -> i32 {
8925 self.0
8926 }
8927
8928 pub const fn empty() -> Self {
8929 Self(0)
8930 }
8931
8932 pub const GENERAL_KHR: Self = Self(0);
8933 pub const TRIANGLES_HIT_GROUP_KHR: Self = Self(1);
8934 pub const PROCEDURAL_HIT_GROUP_KHR: Self = Self(2);
8935 pub const GENERAL_NV: Self = Self(0);
8936 pub const TRIANGLES_HIT_GROUP_NV: Self = Self(1);
8937 pub const PROCEDURAL_HIT_GROUP_NV: Self = Self(2);
8938}
8939
8940#[repr(transparent)]
8941#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8942pub struct AccelerationStructureCompatibilityKHR(pub i32);
8943impl AccelerationStructureCompatibilityKHR {
8944 pub const fn from_raw(value: i32) -> Self {
8945 Self(value)
8946 }
8947
8948 pub const fn as_raw(self) -> i32 {
8949 self.0
8950 }
8951
8952 pub const fn empty() -> Self {
8953 Self(0)
8954 }
8955
8956 pub const COMPATIBLE_KHR: Self = Self(0);
8957 pub const INCOMPATIBLE_KHR: Self = Self(1);
8958}
8959
8960#[repr(transparent)]
8961#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8962pub struct ShaderGroupShaderKHR(pub i32);
8963impl ShaderGroupShaderKHR {
8964 pub const fn from_raw(value: i32) -> Self {
8965 Self(value)
8966 }
8967
8968 pub const fn as_raw(self) -> i32 {
8969 self.0
8970 }
8971
8972 pub const fn empty() -> Self {
8973 Self(0)
8974 }
8975
8976 pub const GENERAL_KHR: Self = Self(0);
8977 pub const CLOSEST_HIT_KHR: Self = Self(1);
8978 pub const ANY_HIT_KHR: Self = Self(2);
8979 pub const INTERSECTION_KHR: Self = Self(3);
8980}
8981
8982#[repr(transparent)]
8983#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
8984pub struct MemoryOverallocationBehaviorAMD(pub i32);
8985impl MemoryOverallocationBehaviorAMD {
8986 pub const fn from_raw(value: i32) -> Self {
8987 Self(value)
8988 }
8989
8990 pub const fn as_raw(self) -> i32 {
8991 self.0
8992 }
8993
8994 pub const fn empty() -> Self {
8995 Self(0)
8996 }
8997
8998 pub const DEFAULT_AMD: Self = Self(0);
8999 pub const ALLOWED_AMD: Self = Self(1);
9000 pub const DISALLOWED_AMD: Self = Self(2);
9001}
9002
9003#[repr(transparent)]
9004#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9005pub struct FramebufferCreateFlagBits(pub u32);
9006impl FramebufferCreateFlagBits {
9007 pub const fn from_raw(value: u32) -> Self {
9008 Self(value)
9009 }
9010
9011 pub const fn as_raw(self) -> u32 {
9012 self.0
9013 }
9014
9015 pub const fn empty() -> Self {
9016 Self(0)
9017 }
9018
9019 pub const IMAGELESS_BIT: Self = Self(1);
9020 pub const IMAGELESS_BIT_KHR: Self = Self(1);
9021}
9022
9023impl std::ops::BitOr for FramebufferCreateFlagBits {
9024 type Output = Self;
9025 fn bitor(self, rhs: Self) -> Self {
9026 Self(self.0 | rhs.0)
9027 }
9028}
9029
9030impl std::ops::BitAnd for FramebufferCreateFlagBits {
9031 type Output = Self;
9032 fn bitand(self, rhs: Self) -> Self {
9033 Self(self.0 & rhs.0)
9034 }
9035}
9036
9037impl std::ops::BitXor for FramebufferCreateFlagBits {
9038 type Output = Self;
9039 fn bitxor(self, rhs: Self) -> Self {
9040 Self(self.0 ^ rhs.0)
9041 }
9042}
9043
9044impl std::ops::Not for FramebufferCreateFlagBits {
9045 type Output = Self;
9046 fn not(self) -> Self {
9047 Self(!self.0)
9048 }
9049}
9050
9051#[repr(transparent)]
9052#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9053pub struct QueryPoolCreateFlagBits(pub u32);
9054impl QueryPoolCreateFlagBits {
9055 pub const fn from_raw(value: u32) -> Self {
9056 Self(value)
9057 }
9058
9059 pub const fn as_raw(self) -> u32 {
9060 self.0
9061 }
9062
9063 pub const fn empty() -> Self {
9064 Self(0)
9065 }
9066
9067 pub const RESET_BIT_KHR: Self = Self(1);
9068}
9069
9070impl std::ops::BitOr for QueryPoolCreateFlagBits {
9071 type Output = Self;
9072 fn bitor(self, rhs: Self) -> Self {
9073 Self(self.0 | rhs.0)
9074 }
9075}
9076
9077impl std::ops::BitAnd for QueryPoolCreateFlagBits {
9078 type Output = Self;
9079 fn bitand(self, rhs: Self) -> Self {
9080 Self(self.0 & rhs.0)
9081 }
9082}
9083
9084impl std::ops::BitXor for QueryPoolCreateFlagBits {
9085 type Output = Self;
9086 fn bitxor(self, rhs: Self) -> Self {
9087 Self(self.0 ^ rhs.0)
9088 }
9089}
9090
9091impl std::ops::Not for QueryPoolCreateFlagBits {
9092 type Output = Self;
9093 fn not(self) -> Self {
9094 Self(!self.0)
9095 }
9096}
9097
9098#[repr(transparent)]
9099#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9100pub struct DeviceDiagnosticsConfigFlagBitsNV(pub u32);
9101impl DeviceDiagnosticsConfigFlagBitsNV {
9102 pub const fn from_raw(value: u32) -> Self {
9103 Self(value)
9104 }
9105
9106 pub const fn as_raw(self) -> u32 {
9107 self.0
9108 }
9109
9110 pub const fn empty() -> Self {
9111 Self(0)
9112 }
9113
9114 pub const ENABLE_SHADER_DEBUG_INFO_BIT_NV: Self = Self(1);
9115 pub const ENABLE_RESOURCE_TRACKING_BIT_NV: Self = Self(2);
9116 pub const ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV: Self = Self(4);
9117 pub const ENABLE_SHADER_ERROR_REPORTING_BIT_NV: Self = Self(8);
9118}
9119
9120impl std::ops::BitOr for DeviceDiagnosticsConfigFlagBitsNV {
9121 type Output = Self;
9122 fn bitor(self, rhs: Self) -> Self {
9123 Self(self.0 | rhs.0)
9124 }
9125}
9126
9127impl std::ops::BitAnd for DeviceDiagnosticsConfigFlagBitsNV {
9128 type Output = Self;
9129 fn bitand(self, rhs: Self) -> Self {
9130 Self(self.0 & rhs.0)
9131 }
9132}
9133
9134impl std::ops::BitXor for DeviceDiagnosticsConfigFlagBitsNV {
9135 type Output = Self;
9136 fn bitxor(self, rhs: Self) -> Self {
9137 Self(self.0 ^ rhs.0)
9138 }
9139}
9140
9141impl std::ops::Not for DeviceDiagnosticsConfigFlagBitsNV {
9142 type Output = Self;
9143 fn not(self) -> Self {
9144 Self(!self.0)
9145 }
9146}
9147
9148#[repr(transparent)]
9149#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9150pub struct PipelineCreationFeedbackFlagBits(pub u32);
9151impl PipelineCreationFeedbackFlagBits {
9152 pub const fn from_raw(value: u32) -> Self {
9153 Self(value)
9154 }
9155
9156 pub const fn as_raw(self) -> u32 {
9157 self.0
9158 }
9159
9160 pub const fn empty() -> Self {
9161 Self(0)
9162 }
9163
9164 pub const VALID_BIT: Self = Self(1);
9165 pub const APPLICATION_PIPELINE_CACHE_HIT_BIT: Self = Self(2);
9166 pub const BASE_PIPELINE_ACCELERATION_BIT: Self = Self(4);
9167 pub const VALID_BIT_EXT: Self = Self(1);
9168 pub const APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT: Self = Self(2);
9169 pub const BASE_PIPELINE_ACCELERATION_BIT_EXT: Self = Self(4);
9170}
9171
9172impl std::ops::BitOr for PipelineCreationFeedbackFlagBits {
9173 type Output = Self;
9174 fn bitor(self, rhs: Self) -> Self {
9175 Self(self.0 | rhs.0)
9176 }
9177}
9178
9179impl std::ops::BitAnd for PipelineCreationFeedbackFlagBits {
9180 type Output = Self;
9181 fn bitand(self, rhs: Self) -> Self {
9182 Self(self.0 & rhs.0)
9183 }
9184}
9185
9186impl std::ops::BitXor for PipelineCreationFeedbackFlagBits {
9187 type Output = Self;
9188 fn bitxor(self, rhs: Self) -> Self {
9189 Self(self.0 ^ rhs.0)
9190 }
9191}
9192
9193impl std::ops::Not for PipelineCreationFeedbackFlagBits {
9194 type Output = Self;
9195 fn not(self) -> Self {
9196 Self(!self.0)
9197 }
9198}
9199
9200#[cfg(feature = "platform-win32")]
9201#[repr(transparent)]
9202#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9203pub struct FullScreenExclusiveEXT(pub i32);
9204#[cfg(feature = "platform-win32")]
9205impl FullScreenExclusiveEXT {
9206 pub const fn from_raw(value: i32) -> Self {
9207 Self(value)
9208 }
9209
9210 pub const fn as_raw(self) -> i32 {
9211 self.0
9212 }
9213
9214 pub const fn empty() -> Self {
9215 Self(0)
9216 }
9217
9218 pub const DEFAULT_EXT: Self = Self(0);
9219 pub const ALLOWED_EXT: Self = Self(1);
9220 pub const DISALLOWED_EXT: Self = Self(2);
9221 pub const APPLICATION_CONTROLLED_EXT: Self = Self(3);
9222}
9223
9224#[repr(transparent)]
9225#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9226pub struct PerformanceCounterScopeKHR(pub i32);
9227impl PerformanceCounterScopeKHR {
9228 pub const fn from_raw(value: i32) -> Self {
9229 Self(value)
9230 }
9231
9232 pub const fn as_raw(self) -> i32 {
9233 self.0
9234 }
9235
9236 pub const fn empty() -> Self {
9237 Self(0)
9238 }
9239
9240 pub const COMMAND_BUFFER_KHR: Self = Self(0);
9241 pub const RENDER_PASS_KHR: Self = Self(1);
9242 pub const COMMAND_KHR: Self = Self(2);
9243 pub const QUERY_SCOPE_COMMAND_BUFFER_KHR: Self = Self(0);
9244 pub const QUERY_SCOPE_RENDER_PASS_KHR: Self = Self(1);
9245 pub const QUERY_SCOPE_COMMAND_KHR: Self = Self(2);
9246}
9247
9248#[repr(transparent)]
9249#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9250pub struct MemoryDecompressionMethodFlagBitsEXT(pub u64);
9251impl MemoryDecompressionMethodFlagBitsEXT {
9252 pub const fn from_raw(value: u64) -> Self {
9253 Self(value)
9254 }
9255
9256 pub const fn as_raw(self) -> u64 {
9257 self.0
9258 }
9259
9260 pub const fn empty() -> Self {
9261 Self(0)
9262 }
9263
9264 pub const GDEFLATE_1_0_BIT_EXT: Self = Self(1);
9265 pub const GDEFLATE_1_0_BIT_NV: Self = Self(1);
9266}
9267
9268impl std::ops::BitOr for MemoryDecompressionMethodFlagBitsEXT {
9269 type Output = Self;
9270 fn bitor(self, rhs: Self) -> Self {
9271 Self(self.0 | rhs.0)
9272 }
9273}
9274
9275impl std::ops::BitAnd for MemoryDecompressionMethodFlagBitsEXT {
9276 type Output = Self;
9277 fn bitand(self, rhs: Self) -> Self {
9278 Self(self.0 & rhs.0)
9279 }
9280}
9281
9282impl std::ops::BitXor for MemoryDecompressionMethodFlagBitsEXT {
9283 type Output = Self;
9284 fn bitxor(self, rhs: Self) -> Self {
9285 Self(self.0 ^ rhs.0)
9286 }
9287}
9288
9289impl std::ops::Not for MemoryDecompressionMethodFlagBitsEXT {
9290 type Output = Self;
9291 fn not(self) -> Self {
9292 Self(!self.0)
9293 }
9294}
9295
9296#[repr(transparent)]
9297#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9298pub struct PerformanceCounterUnitKHR(pub i32);
9299impl PerformanceCounterUnitKHR {
9300 pub const fn from_raw(value: i32) -> Self {
9301 Self(value)
9302 }
9303
9304 pub const fn as_raw(self) -> i32 {
9305 self.0
9306 }
9307
9308 pub const fn empty() -> Self {
9309 Self(0)
9310 }
9311
9312 pub const GENERIC_KHR: Self = Self(0);
9313 pub const PERCENTAGE_KHR: Self = Self(1);
9314 pub const NANOSECONDS_KHR: Self = Self(2);
9315 pub const BYTES_KHR: Self = Self(3);
9316 pub const BYTES_PER_SECOND_KHR: Self = Self(4);
9317 pub const KELVIN_KHR: Self = Self(5);
9318 pub const WATTS_KHR: Self = Self(6);
9319 pub const VOLTS_KHR: Self = Self(7);
9320 pub const AMPS_KHR: Self = Self(8);
9321 pub const HERTZ_KHR: Self = Self(9);
9322 pub const CYCLES_KHR: Self = Self(10);
9323}
9324
9325#[repr(transparent)]
9326#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9327pub struct PerformanceCounterStorageKHR(pub i32);
9328impl PerformanceCounterStorageKHR {
9329 pub const fn from_raw(value: i32) -> Self {
9330 Self(value)
9331 }
9332
9333 pub const fn as_raw(self) -> i32 {
9334 self.0
9335 }
9336
9337 pub const fn empty() -> Self {
9338 Self(0)
9339 }
9340
9341 pub const INT32_KHR: Self = Self(0);
9342 pub const INT64_KHR: Self = Self(1);
9343 pub const UINT32_KHR: Self = Self(2);
9344 pub const UINT64_KHR: Self = Self(3);
9345 pub const FLOAT32_KHR: Self = Self(4);
9346 pub const FLOAT64_KHR: Self = Self(5);
9347}
9348
9349#[repr(transparent)]
9350#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9351pub struct PerformanceCounterDescriptionFlagBitsKHR(pub u32);
9352impl PerformanceCounterDescriptionFlagBitsKHR {
9353 pub const fn from_raw(value: u32) -> Self {
9354 Self(value)
9355 }
9356
9357 pub const fn as_raw(self) -> u32 {
9358 self.0
9359 }
9360
9361 pub const fn empty() -> Self {
9362 Self(0)
9363 }
9364
9365 pub const PERFORMANCE_IMPACTING_BIT_KHR: Self = Self(1);
9366 pub const PERFORMANCE_IMPACTING_KHR: Self = Self(1);
9367 pub const CONCURRENTLY_IMPACTED_BIT_KHR: Self = Self(2);
9368 pub const CONCURRENTLY_IMPACTED_KHR: Self = Self(2);
9369}
9370
9371impl std::ops::BitOr for PerformanceCounterDescriptionFlagBitsKHR {
9372 type Output = Self;
9373 fn bitor(self, rhs: Self) -> Self {
9374 Self(self.0 | rhs.0)
9375 }
9376}
9377
9378impl std::ops::BitAnd for PerformanceCounterDescriptionFlagBitsKHR {
9379 type Output = Self;
9380 fn bitand(self, rhs: Self) -> Self {
9381 Self(self.0 & rhs.0)
9382 }
9383}
9384
9385impl std::ops::BitXor for PerformanceCounterDescriptionFlagBitsKHR {
9386 type Output = Self;
9387 fn bitxor(self, rhs: Self) -> Self {
9388 Self(self.0 ^ rhs.0)
9389 }
9390}
9391
9392impl std::ops::Not for PerformanceCounterDescriptionFlagBitsKHR {
9393 type Output = Self;
9394 fn not(self) -> Self {
9395 Self(!self.0)
9396 }
9397}
9398
9399#[repr(transparent)]
9400#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9401pub struct AcquireProfilingLockFlagBitsKHR(pub u32);
9402impl AcquireProfilingLockFlagBitsKHR {
9403 pub const fn from_raw(value: u32) -> Self {
9404 Self(value)
9405 }
9406
9407 pub const fn as_raw(self) -> u32 {
9408 self.0
9409 }
9410
9411 pub const fn empty() -> Self {
9412 Self(0)
9413 }
9414}
9415
9416impl std::ops::BitOr for AcquireProfilingLockFlagBitsKHR {
9417 type Output = Self;
9418 fn bitor(self, rhs: Self) -> Self {
9419 Self(self.0 | rhs.0)
9420 }
9421}
9422
9423impl std::ops::BitAnd for AcquireProfilingLockFlagBitsKHR {
9424 type Output = Self;
9425 fn bitand(self, rhs: Self) -> Self {
9426 Self(self.0 & rhs.0)
9427 }
9428}
9429
9430impl std::ops::BitXor for AcquireProfilingLockFlagBitsKHR {
9431 type Output = Self;
9432 fn bitxor(self, rhs: Self) -> Self {
9433 Self(self.0 ^ rhs.0)
9434 }
9435}
9436
9437impl std::ops::Not for AcquireProfilingLockFlagBitsKHR {
9438 type Output = Self;
9439 fn not(self) -> Self {
9440 Self(!self.0)
9441 }
9442}
9443
9444#[repr(transparent)]
9445#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9446pub struct ShaderCorePropertiesFlagBitsAMD(pub u32);
9447impl ShaderCorePropertiesFlagBitsAMD {
9448 pub const fn from_raw(value: u32) -> Self {
9449 Self(value)
9450 }
9451
9452 pub const fn as_raw(self) -> u32 {
9453 self.0
9454 }
9455
9456 pub const fn empty() -> Self {
9457 Self(0)
9458 }
9459}
9460
9461impl std::ops::BitOr for ShaderCorePropertiesFlagBitsAMD {
9462 type Output = Self;
9463 fn bitor(self, rhs: Self) -> Self {
9464 Self(self.0 | rhs.0)
9465 }
9466}
9467
9468impl std::ops::BitAnd for ShaderCorePropertiesFlagBitsAMD {
9469 type Output = Self;
9470 fn bitand(self, rhs: Self) -> Self {
9471 Self(self.0 & rhs.0)
9472 }
9473}
9474
9475impl std::ops::BitXor for ShaderCorePropertiesFlagBitsAMD {
9476 type Output = Self;
9477 fn bitxor(self, rhs: Self) -> Self {
9478 Self(self.0 ^ rhs.0)
9479 }
9480}
9481
9482impl std::ops::Not for ShaderCorePropertiesFlagBitsAMD {
9483 type Output = Self;
9484 fn not(self) -> Self {
9485 Self(!self.0)
9486 }
9487}
9488
9489#[repr(transparent)]
9490#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9491pub struct PerformanceConfigurationTypeINTEL(pub i32);
9492impl PerformanceConfigurationTypeINTEL {
9493 pub const fn from_raw(value: i32) -> Self {
9494 Self(value)
9495 }
9496
9497 pub const fn as_raw(self) -> i32 {
9498 self.0
9499 }
9500
9501 pub const fn empty() -> Self {
9502 Self(0)
9503 }
9504
9505 pub const COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL: Self = Self(0);
9506}
9507
9508#[repr(transparent)]
9509#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9510pub struct QueryPoolSamplingModeINTEL(pub i32);
9511impl QueryPoolSamplingModeINTEL {
9512 pub const fn from_raw(value: i32) -> Self {
9513 Self(value)
9514 }
9515
9516 pub const fn as_raw(self) -> i32 {
9517 self.0
9518 }
9519
9520 pub const fn empty() -> Self {
9521 Self(0)
9522 }
9523
9524 pub const MANUAL_INTEL: Self = Self(0);
9525}
9526
9527#[repr(transparent)]
9528#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9529pub struct PerformanceOverrideTypeINTEL(pub i32);
9530impl PerformanceOverrideTypeINTEL {
9531 pub const fn from_raw(value: i32) -> Self {
9532 Self(value)
9533 }
9534
9535 pub const fn as_raw(self) -> i32 {
9536 self.0
9537 }
9538
9539 pub const fn empty() -> Self {
9540 Self(0)
9541 }
9542
9543 pub const NULL_HARDWARE_INTEL: Self = Self(0);
9544 pub const FLUSH_GPU_CACHES_INTEL: Self = Self(1);
9545}
9546
9547#[repr(transparent)]
9548#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9549pub struct PerformanceParameterTypeINTEL(pub i32);
9550impl PerformanceParameterTypeINTEL {
9551 pub const fn from_raw(value: i32) -> Self {
9552 Self(value)
9553 }
9554
9555 pub const fn as_raw(self) -> i32 {
9556 self.0
9557 }
9558
9559 pub const fn empty() -> Self {
9560 Self(0)
9561 }
9562
9563 pub const HW_COUNTERS_SUPPORTED_INTEL: Self = Self(0);
9564 pub const STREAM_MARKER_VALID_BITS_INTEL: Self = Self(1);
9565}
9566
9567#[repr(transparent)]
9568#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9569pub struct PerformanceValueTypeINTEL(pub i32);
9570impl PerformanceValueTypeINTEL {
9571 pub const fn from_raw(value: i32) -> Self {
9572 Self(value)
9573 }
9574
9575 pub const fn as_raw(self) -> i32 {
9576 self.0
9577 }
9578
9579 pub const fn empty() -> Self {
9580 Self(0)
9581 }
9582
9583 pub const UINT32_INTEL: Self = Self(0);
9584 pub const UINT64_INTEL: Self = Self(1);
9585 pub const FLOAT_INTEL: Self = Self(2);
9586 pub const BOOL_INTEL: Self = Self(3);
9587 pub const STRING_INTEL: Self = Self(4);
9588}
9589
9590#[repr(transparent)]
9591#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9592pub struct ShaderFloatControlsIndependence(pub i32);
9593impl ShaderFloatControlsIndependence {
9594 pub const fn from_raw(value: i32) -> Self {
9595 Self(value)
9596 }
9597
9598 pub const fn as_raw(self) -> i32 {
9599 self.0
9600 }
9601
9602 pub const fn empty() -> Self {
9603 Self(0)
9604 }
9605
9606 pub const _32_BIT_ONLY: Self = Self(0);
9607 pub const ALL: Self = Self(1);
9608 pub const NONE: Self = Self(2);
9609 pub const _32_BIT_ONLY_KHR: Self = Self(0);
9610 pub const ALL_KHR: Self = Self(1);
9611 pub const NONE_KHR: Self = Self(2);
9612}
9613
9614#[repr(transparent)]
9615#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9616pub struct PipelineExecutableStatisticFormatKHR(pub i32);
9617impl PipelineExecutableStatisticFormatKHR {
9618 pub const fn from_raw(value: i32) -> Self {
9619 Self(value)
9620 }
9621
9622 pub const fn as_raw(self) -> i32 {
9623 self.0
9624 }
9625
9626 pub const fn empty() -> Self {
9627 Self(0)
9628 }
9629
9630 pub const BOOL32_KHR: Self = Self(0);
9631 pub const INT64_KHR: Self = Self(1);
9632 pub const UINT64_KHR: Self = Self(2);
9633 pub const FLOAT64_KHR: Self = Self(3);
9634}
9635
9636#[repr(transparent)]
9637#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9638pub struct LineRasterizationMode(pub i32);
9639impl LineRasterizationMode {
9640 pub const fn from_raw(value: i32) -> Self {
9641 Self(value)
9642 }
9643
9644 pub const fn as_raw(self) -> i32 {
9645 self.0
9646 }
9647
9648 pub const fn empty() -> Self {
9649 Self(0)
9650 }
9651
9652 pub const DEFAULT: Self = Self(0);
9653 pub const RECTANGULAR: Self = Self(1);
9654 pub const BRESENHAM: Self = Self(2);
9655 pub const RECTANGULAR_SMOOTH: Self = Self(3);
9656 pub const DEFAULT_EXT: Self = Self(0);
9657 pub const RECTANGULAR_EXT: Self = Self(1);
9658 pub const BRESENHAM_EXT: Self = Self(2);
9659 pub const RECTANGULAR_SMOOTH_EXT: Self = Self(3);
9660 pub const DEFAULT_KHR: Self = Self(0);
9661 pub const RECTANGULAR_KHR: Self = Self(1);
9662 pub const BRESENHAM_KHR: Self = Self(2);
9663 pub const RECTANGULAR_SMOOTH_KHR: Self = Self(3);
9664}
9665
9666#[repr(transparent)]
9667#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9668pub struct PipelineCompilerControlFlagBitsAMD(pub u32);
9669impl PipelineCompilerControlFlagBitsAMD {
9670 pub const fn from_raw(value: u32) -> Self {
9671 Self(value)
9672 }
9673
9674 pub const fn as_raw(self) -> u32 {
9675 self.0
9676 }
9677
9678 pub const fn empty() -> Self {
9679 Self(0)
9680 }
9681}
9682
9683impl std::ops::BitOr for PipelineCompilerControlFlagBitsAMD {
9684 type Output = Self;
9685 fn bitor(self, rhs: Self) -> Self {
9686 Self(self.0 | rhs.0)
9687 }
9688}
9689
9690impl std::ops::BitAnd for PipelineCompilerControlFlagBitsAMD {
9691 type Output = Self;
9692 fn bitand(self, rhs: Self) -> Self {
9693 Self(self.0 & rhs.0)
9694 }
9695}
9696
9697impl std::ops::BitXor for PipelineCompilerControlFlagBitsAMD {
9698 type Output = Self;
9699 fn bitxor(self, rhs: Self) -> Self {
9700 Self(self.0 ^ rhs.0)
9701 }
9702}
9703
9704impl std::ops::Not for PipelineCompilerControlFlagBitsAMD {
9705 type Output = Self;
9706 fn not(self) -> Self {
9707 Self(!self.0)
9708 }
9709}
9710
9711#[repr(transparent)]
9712#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9713pub struct ToolPurposeFlagBits(pub u32);
9714impl ToolPurposeFlagBits {
9715 pub const fn from_raw(value: u32) -> Self {
9716 Self(value)
9717 }
9718
9719 pub const fn as_raw(self) -> u32 {
9720 self.0
9721 }
9722
9723 pub const fn empty() -> Self {
9724 Self(0)
9725 }
9726
9727 pub const VALIDATION_BIT: Self = Self(1);
9728 pub const PROFILING_BIT: Self = Self(2);
9729 pub const TRACING_BIT: Self = Self(4);
9730 pub const ADDITIONAL_FEATURES_BIT: Self = Self(8);
9731 pub const MODIFYING_FEATURES_BIT: Self = Self(16);
9732 pub const VALIDATION_BIT_EXT: Self = Self(1);
9733 pub const PROFILING_BIT_EXT: Self = Self(2);
9734 pub const TRACING_BIT_EXT: Self = Self(4);
9735 pub const ADDITIONAL_FEATURES_BIT_EXT: Self = Self(8);
9736 pub const MODIFYING_FEATURES_BIT_EXT: Self = Self(16);
9737 pub const DEBUG_REPORTING_BIT_EXT: Self = Self(32);
9738 pub const DEBUG_MARKERS_BIT_EXT: Self = Self(64);
9739}
9740
9741impl std::ops::BitOr for ToolPurposeFlagBits {
9742 type Output = Self;
9743 fn bitor(self, rhs: Self) -> Self {
9744 Self(self.0 | rhs.0)
9745 }
9746}
9747
9748impl std::ops::BitAnd for ToolPurposeFlagBits {
9749 type Output = Self;
9750 fn bitand(self, rhs: Self) -> Self {
9751 Self(self.0 & rhs.0)
9752 }
9753}
9754
9755impl std::ops::BitXor for ToolPurposeFlagBits {
9756 type Output = Self;
9757 fn bitxor(self, rhs: Self) -> Self {
9758 Self(self.0 ^ rhs.0)
9759 }
9760}
9761
9762impl std::ops::Not for ToolPurposeFlagBits {
9763 type Output = Self;
9764 fn not(self) -> Self {
9765 Self(!self.0)
9766 }
9767}
9768
9769#[repr(transparent)]
9770#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9771pub struct FragmentShadingRateCombinerOpKHR(pub i32);
9772impl FragmentShadingRateCombinerOpKHR {
9773 pub const fn from_raw(value: i32) -> Self {
9774 Self(value)
9775 }
9776
9777 pub const fn as_raw(self) -> i32 {
9778 self.0
9779 }
9780
9781 pub const fn empty() -> Self {
9782 Self(0)
9783 }
9784
9785 pub const KEEP_KHR: Self = Self(0);
9786 pub const REPLACE_KHR: Self = Self(1);
9787 pub const MIN_KHR: Self = Self(2);
9788 pub const MAX_KHR: Self = Self(3);
9789 pub const MUL_KHR: Self = Self(4);
9790}
9791
9792#[repr(transparent)]
9793#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9794pub struct FragmentShadingRateNV(pub i32);
9795impl FragmentShadingRateNV {
9796 pub const fn from_raw(value: i32) -> Self {
9797 Self(value)
9798 }
9799
9800 pub const fn as_raw(self) -> i32 {
9801 self.0
9802 }
9803
9804 pub const fn empty() -> Self {
9805 Self(0)
9806 }
9807
9808 pub const _1_INVOCATION_PER_PIXEL_NV: Self = Self(0);
9809 pub const _1_INVOCATION_PER_1X2_PIXELS_NV: Self = Self(1);
9810 pub const _1_INVOCATION_PER_2X1_PIXELS_NV: Self = Self(4);
9811 pub const _1_INVOCATION_PER_2X2_PIXELS_NV: Self = Self(5);
9812 pub const _1_INVOCATION_PER_2X4_PIXELS_NV: Self = Self(6);
9813 pub const _1_INVOCATION_PER_4X2_PIXELS_NV: Self = Self(9);
9814 pub const _1_INVOCATION_PER_4X4_PIXELS_NV: Self = Self(10);
9815 pub const _2_INVOCATIONS_PER_PIXEL_NV: Self = Self(11);
9816 pub const _4_INVOCATIONS_PER_PIXEL_NV: Self = Self(12);
9817 pub const _8_INVOCATIONS_PER_PIXEL_NV: Self = Self(13);
9818 pub const _16_INVOCATIONS_PER_PIXEL_NV: Self = Self(14);
9819 pub const NO_INVOCATIONS_NV: Self = Self(15);
9820}
9821
9822#[repr(transparent)]
9823#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9824pub struct FragmentShadingRateTypeNV(pub i32);
9825impl FragmentShadingRateTypeNV {
9826 pub const fn from_raw(value: i32) -> Self {
9827 Self(value)
9828 }
9829
9830 pub const fn as_raw(self) -> i32 {
9831 self.0
9832 }
9833
9834 pub const fn empty() -> Self {
9835 Self(0)
9836 }
9837
9838 pub const FRAGMENT_SIZE_NV: Self = Self(0);
9839 pub const ENUMS_NV: Self = Self(1);
9840}
9841
9842#[repr(transparent)]
9843#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9844pub struct SubpassMergeStatusEXT(pub i32);
9845impl SubpassMergeStatusEXT {
9846 pub const fn from_raw(value: i32) -> Self {
9847 Self(value)
9848 }
9849
9850 pub const fn as_raw(self) -> i32 {
9851 self.0
9852 }
9853
9854 pub const fn empty() -> Self {
9855 Self(0)
9856 }
9857
9858 pub const MERGED_EXT: Self = Self(0);
9859 pub const DISALLOWED_EXT: Self = Self(1);
9860 pub const NOT_MERGED_SIDE_EFFECTS_EXT: Self = Self(2);
9861 pub const NOT_MERGED_SAMPLES_MISMATCH_EXT: Self = Self(3);
9862 pub const NOT_MERGED_VIEWS_MISMATCH_EXT: Self = Self(4);
9863 pub const NOT_MERGED_ALIASING_EXT: Self = Self(5);
9864 pub const NOT_MERGED_DEPENDENCIES_EXT: Self = Self(6);
9865 pub const NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT: Self = Self(7);
9866 pub const NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT: Self = Self(8);
9867 pub const NOT_MERGED_INSUFFICIENT_STORAGE_EXT: Self = Self(9);
9868 pub const NOT_MERGED_DEPTH_STENCIL_COUNT_EXT: Self = Self(10);
9869 pub const NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT: Self = Self(11);
9870 pub const NOT_MERGED_SINGLE_SUBPASS_EXT: Self = Self(12);
9871 pub const NOT_MERGED_UNSPECIFIED_EXT: Self = Self(13);
9872}
9873
9874#[repr(transparent)]
9875#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9876pub struct AccessFlagBits2(pub u64);
9877impl AccessFlagBits2 {
9878 pub const fn from_raw(value: u64) -> Self {
9879 Self(value)
9880 }
9881
9882 pub const fn as_raw(self) -> u64 {
9883 self.0
9884 }
9885
9886 pub const fn empty() -> Self {
9887 Self(0)
9888 }
9889
9890 pub const NONE: Self = Self(0);
9891 pub const INDIRECT_COMMAND_READ_BIT: Self = Self(1);
9892 pub const INDEX_READ_BIT: Self = Self(2);
9893 pub const VERTEX_ATTRIBUTE_READ_BIT: Self = Self(4);
9894 pub const UNIFORM_READ_BIT: Self = Self(8);
9895 pub const INPUT_ATTACHMENT_READ_BIT: Self = Self(16);
9896 pub const SHADER_READ_BIT: Self = Self(32);
9897 pub const SHADER_WRITE_BIT: Self = Self(64);
9898 pub const COLOR_ATTACHMENT_READ_BIT: Self = Self(128);
9899 pub const COLOR_ATTACHMENT_WRITE_BIT: Self = Self(256);
9900 pub const DEPTH_STENCIL_ATTACHMENT_READ_BIT: Self = Self(512);
9901 pub const DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: Self = Self(1024);
9902 pub const TRANSFER_READ_BIT: Self = Self(2048);
9903 pub const TRANSFER_WRITE_BIT: Self = Self(4096);
9904 pub const HOST_READ_BIT: Self = Self(8192);
9905 pub const HOST_WRITE_BIT: Self = Self(16384);
9906 pub const MEMORY_READ_BIT: Self = Self(32768);
9907 pub const MEMORY_WRITE_BIT: Self = Self(65536);
9908 pub const SHADER_SAMPLED_READ_BIT: Self = Self(4294967296);
9909 pub const SHADER_STORAGE_READ_BIT: Self = Self(8589934592);
9910 pub const SHADER_STORAGE_WRITE_BIT: Self = Self(17179869184);
9911 pub const VIDEO_DECODE_READ_BIT_KHR: Self = Self(34359738368);
9912 pub const VIDEO_DECODE_WRITE_BIT_KHR: Self = Self(68719476736);
9913 pub const SAMPLER_HEAP_READ_BIT_EXT: Self = Self(144115188075855872);
9914 pub const RESOURCE_HEAP_READ_BIT_EXT: Self = Self(288230376151711744);
9915 pub const VIDEO_ENCODE_READ_BIT_KHR: Self = Self(137438953472);
9916 pub const VIDEO_ENCODE_WRITE_BIT_KHR: Self = Self(274877906944);
9917 pub const SHADER_TILE_ATTACHMENT_READ_BIT_QCOM: Self = Self(2251799813685248);
9918 pub const SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM: Self = Self(4503599627370496);
9919 pub const NONE_KHR: Self = Self(0);
9920 pub const INDIRECT_COMMAND_READ_BIT_KHR: Self = Self(1);
9921 pub const INDEX_READ_BIT_KHR: Self = Self(2);
9922 pub const VERTEX_ATTRIBUTE_READ_BIT_KHR: Self = Self(4);
9923 pub const UNIFORM_READ_BIT_KHR: Self = Self(8);
9924 pub const INPUT_ATTACHMENT_READ_BIT_KHR: Self = Self(16);
9925 pub const SHADER_READ_BIT_KHR: Self = Self(32);
9926 pub const SHADER_WRITE_BIT_KHR: Self = Self(64);
9927 pub const COLOR_ATTACHMENT_READ_BIT_KHR: Self = Self(128);
9928 pub const COLOR_ATTACHMENT_WRITE_BIT_KHR: Self = Self(256);
9929 pub const DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR: Self = Self(512);
9930 pub const DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR: Self = Self(1024);
9931 pub const TRANSFER_READ_BIT_KHR: Self = Self(2048);
9932 pub const TRANSFER_WRITE_BIT_KHR: Self = Self(4096);
9933 pub const HOST_READ_BIT_KHR: Self = Self(8192);
9934 pub const HOST_WRITE_BIT_KHR: Self = Self(16384);
9935 pub const MEMORY_READ_BIT_KHR: Self = Self(32768);
9936 pub const MEMORY_WRITE_BIT_KHR: Self = Self(65536);
9937 pub const SHADER_SAMPLED_READ_BIT_KHR: Self = Self(4294967296);
9938 pub const SHADER_STORAGE_READ_BIT_KHR: Self = Self(8589934592);
9939 pub const SHADER_STORAGE_WRITE_BIT_KHR: Self = Self(17179869184);
9940 pub const TRANSFORM_FEEDBACK_WRITE_BIT_EXT: Self = Self(33554432);
9941 pub const TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: Self = Self(67108864);
9942 pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: Self = Self(134217728);
9943 pub const CONDITIONAL_RENDERING_READ_BIT_EXT: Self = Self(1048576);
9944 pub const COMMAND_PREPROCESS_READ_BIT_NV: Self = Self(131072);
9945 pub const COMMAND_PREPROCESS_WRITE_BIT_NV: Self = Self(262144);
9946 pub const COMMAND_PREPROCESS_READ_BIT_EXT: Self = Self(131072);
9947 pub const COMMAND_PREPROCESS_WRITE_BIT_EXT: Self = Self(262144);
9948 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: Self = Self(8388608);
9949 pub const SHADING_RATE_IMAGE_READ_BIT_NV: Self = Self(8388608);
9950 pub const ACCELERATION_STRUCTURE_READ_BIT_KHR: Self = Self(2097152);
9951 pub const ACCELERATION_STRUCTURE_WRITE_BIT_KHR: Self = Self(4194304);
9952 pub const ACCELERATION_STRUCTURE_READ_BIT_NV: Self = Self(2097152);
9953 pub const ACCELERATION_STRUCTURE_WRITE_BIT_NV: Self = Self(4194304);
9954 pub const FRAGMENT_DENSITY_MAP_READ_BIT_EXT: Self = Self(16777216);
9955 pub const COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: Self = Self(524288);
9956 pub const DESCRIPTOR_BUFFER_READ_BIT_EXT: Self = Self(2199023255552);
9957 pub const INVOCATION_MASK_READ_BIT_HUAWEI: Self = Self(549755813888);
9958 pub const SHADER_BINDING_TABLE_READ_BIT_KHR: Self = Self(1099511627776);
9959 pub const MICROMAP_READ_BIT_EXT: Self = Self(17592186044416);
9960 pub const MICROMAP_WRITE_BIT_EXT: Self = Self(35184372088832);
9961 pub const OPTICAL_FLOW_READ_BIT_NV: Self = Self(4398046511104);
9962 pub const OPTICAL_FLOW_WRITE_BIT_NV: Self = Self(8796093022208);
9963 pub const DATA_GRAPH_READ_BIT_ARM: Self = Self(140737488355328);
9964 pub const DATA_GRAPH_WRITE_BIT_ARM: Self = Self(281474976710656);
9965 pub const MEMORY_DECOMPRESSION_READ_BIT_EXT: Self = Self(36028797018963968);
9966 pub const MEMORY_DECOMPRESSION_WRITE_BIT_EXT: Self = Self(72057594037927936);
9967}
9968
9969impl std::ops::BitOr for AccessFlagBits2 {
9970 type Output = Self;
9971 fn bitor(self, rhs: Self) -> Self {
9972 Self(self.0 | rhs.0)
9973 }
9974}
9975
9976impl std::ops::BitAnd for AccessFlagBits2 {
9977 type Output = Self;
9978 fn bitand(self, rhs: Self) -> Self {
9979 Self(self.0 & rhs.0)
9980 }
9981}
9982
9983impl std::ops::BitXor for AccessFlagBits2 {
9984 type Output = Self;
9985 fn bitxor(self, rhs: Self) -> Self {
9986 Self(self.0 ^ rhs.0)
9987 }
9988}
9989
9990impl std::ops::Not for AccessFlagBits2 {
9991 type Output = Self;
9992 fn not(self) -> Self {
9993 Self(!self.0)
9994 }
9995}
9996
9997#[repr(transparent)]
9998#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
9999pub struct PipelineStageFlagBits2(pub u64);
10000impl PipelineStageFlagBits2 {
10001 pub const fn from_raw(value: u64) -> Self {
10002 Self(value)
10003 }
10004
10005 pub const fn as_raw(self) -> u64 {
10006 self.0
10007 }
10008
10009 pub const fn empty() -> Self {
10010 Self(0)
10011 }
10012
10013 pub const NONE: Self = Self(0);
10014 pub const TOP_OF_PIPE_BIT: Self = Self(1);
10015 pub const DRAW_INDIRECT_BIT: Self = Self(2);
10016 pub const VERTEX_INPUT_BIT: Self = Self(4);
10017 pub const VERTEX_SHADER_BIT: Self = Self(8);
10018 pub const TESSELLATION_CONTROL_SHADER_BIT: Self = Self(16);
10019 pub const TESSELLATION_EVALUATION_SHADER_BIT: Self = Self(32);
10020 pub const GEOMETRY_SHADER_BIT: Self = Self(64);
10021 pub const FRAGMENT_SHADER_BIT: Self = Self(128);
10022 pub const EARLY_FRAGMENT_TESTS_BIT: Self = Self(256);
10023 pub const LATE_FRAGMENT_TESTS_BIT: Self = Self(512);
10024 pub const COLOR_ATTACHMENT_OUTPUT_BIT: Self = Self(1024);
10025 pub const COMPUTE_SHADER_BIT: Self = Self(2048);
10026 pub const ALL_TRANSFER_BIT: Self = Self(4096);
10027 pub const TRANSFER_BIT: Self = Self(4096);
10028 pub const BOTTOM_OF_PIPE_BIT: Self = Self(8192);
10029 pub const HOST_BIT: Self = Self(16384);
10030 pub const ALL_GRAPHICS_BIT: Self = Self(32768);
10031 pub const ALL_COMMANDS_BIT: Self = Self(65536);
10032 pub const COPY_BIT: Self = Self(4294967296);
10033 pub const RESOLVE_BIT: Self = Self(8589934592);
10034 pub const BLIT_BIT: Self = Self(17179869184);
10035 pub const CLEAR_BIT: Self = Self(34359738368);
10036 pub const INDEX_INPUT_BIT: Self = Self(68719476736);
10037 pub const VERTEX_ATTRIBUTE_INPUT_BIT: Self = Self(137438953472);
10038 pub const PRE_RASTERIZATION_SHADERS_BIT: Self = Self(274877906944);
10039 pub const VIDEO_DECODE_BIT_KHR: Self = Self(67108864);
10040 pub const VIDEO_ENCODE_BIT_KHR: Self = Self(134217728);
10041 pub const NONE_KHR: Self = Self(0);
10042 pub const TOP_OF_PIPE_BIT_KHR: Self = Self(1);
10043 pub const DRAW_INDIRECT_BIT_KHR: Self = Self(2);
10044 pub const VERTEX_INPUT_BIT_KHR: Self = Self(4);
10045 pub const VERTEX_SHADER_BIT_KHR: Self = Self(8);
10046 pub const TESSELLATION_CONTROL_SHADER_BIT_KHR: Self = Self(16);
10047 pub const TESSELLATION_EVALUATION_SHADER_BIT_KHR: Self = Self(32);
10048 pub const GEOMETRY_SHADER_BIT_KHR: Self = Self(64);
10049 pub const FRAGMENT_SHADER_BIT_KHR: Self = Self(128);
10050 pub const EARLY_FRAGMENT_TESTS_BIT_KHR: Self = Self(256);
10051 pub const LATE_FRAGMENT_TESTS_BIT_KHR: Self = Self(512);
10052 pub const COLOR_ATTACHMENT_OUTPUT_BIT_KHR: Self = Self(1024);
10053 pub const COMPUTE_SHADER_BIT_KHR: Self = Self(2048);
10054 pub const ALL_TRANSFER_BIT_KHR: Self = Self(4096);
10055 pub const TRANSFER_BIT_KHR: Self = Self(4096);
10056 pub const BOTTOM_OF_PIPE_BIT_KHR: Self = Self(8192);
10057 pub const HOST_BIT_KHR: Self = Self(16384);
10058 pub const ALL_GRAPHICS_BIT_KHR: Self = Self(32768);
10059 pub const ALL_COMMANDS_BIT_KHR: Self = Self(65536);
10060 pub const COPY_BIT_KHR: Self = Self(4294967296);
10061 pub const RESOLVE_BIT_KHR: Self = Self(8589934592);
10062 pub const BLIT_BIT_KHR: Self = Self(17179869184);
10063 pub const CLEAR_BIT_KHR: Self = Self(34359738368);
10064 pub const INDEX_INPUT_BIT_KHR: Self = Self(68719476736);
10065 pub const VERTEX_ATTRIBUTE_INPUT_BIT_KHR: Self = Self(137438953472);
10066 pub const PRE_RASTERIZATION_SHADERS_BIT_KHR: Self = Self(274877906944);
10067 pub const TRANSFORM_FEEDBACK_BIT_EXT: Self = Self(16777216);
10068 pub const CONDITIONAL_RENDERING_BIT_EXT: Self = Self(262144);
10069 pub const COMMAND_PREPROCESS_BIT_NV: Self = Self(131072);
10070 pub const COMMAND_PREPROCESS_BIT_EXT: Self = Self(131072);
10071 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self = Self(4194304);
10072 pub const SHADING_RATE_IMAGE_BIT_NV: Self = Self(4194304);
10073 pub const ACCELERATION_STRUCTURE_BUILD_BIT_KHR: Self = Self(33554432);
10074 pub const RAY_TRACING_SHADER_BIT_KHR: Self = Self(2097152);
10075 pub const RAY_TRACING_SHADER_BIT_NV: Self = Self(2097152);
10076 pub const ACCELERATION_STRUCTURE_BUILD_BIT_NV: Self = Self(33554432);
10077 pub const FRAGMENT_DENSITY_PROCESS_BIT_EXT: Self = Self(8388608);
10078 pub const TASK_SHADER_BIT_NV: Self = Self(524288);
10079 pub const MESH_SHADER_BIT_NV: Self = Self(1048576);
10080 pub const TASK_SHADER_BIT_EXT: Self = Self(524288);
10081 pub const MESH_SHADER_BIT_EXT: Self = Self(1048576);
10082 pub const SUBPASS_SHADER_BIT_HUAWEI: Self = Self(549755813888);
10083 pub const SUBPASS_SHADING_BIT_HUAWEI: Self = Self(549755813888);
10084 pub const INVOCATION_MASK_BIT_HUAWEI: Self = Self(1099511627776);
10085 pub const ACCELERATION_STRUCTURE_COPY_BIT_KHR: Self = Self(268435456);
10086 pub const MICROMAP_BUILD_BIT_EXT: Self = Self(1073741824);
10087 pub const CLUSTER_CULLING_SHADER_BIT_HUAWEI: Self = Self(2199023255552);
10088 pub const OPTICAL_FLOW_BIT_NV: Self = Self(536870912);
10089 pub const CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV: Self = Self(17592186044416);
10090 pub const DATA_GRAPH_BIT_ARM: Self = Self(4398046511104);
10091 pub const COPY_INDIRECT_BIT_KHR: Self = Self(70368744177664);
10092 pub const MEMORY_DECOMPRESSION_BIT_EXT: Self = Self(35184372088832);
10093}
10094
10095impl std::ops::BitOr for PipelineStageFlagBits2 {
10096 type Output = Self;
10097 fn bitor(self, rhs: Self) -> Self {
10098 Self(self.0 | rhs.0)
10099 }
10100}
10101
10102impl std::ops::BitAnd for PipelineStageFlagBits2 {
10103 type Output = Self;
10104 fn bitand(self, rhs: Self) -> Self {
10105 Self(self.0 & rhs.0)
10106 }
10107}
10108
10109impl std::ops::BitXor for PipelineStageFlagBits2 {
10110 type Output = Self;
10111 fn bitxor(self, rhs: Self) -> Self {
10112 Self(self.0 ^ rhs.0)
10113 }
10114}
10115
10116impl std::ops::Not for PipelineStageFlagBits2 {
10117 type Output = Self;
10118 fn not(self) -> Self {
10119 Self(!self.0)
10120 }
10121}
10122
10123#[repr(transparent)]
10124#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10125pub struct SubmitFlagBits(pub u32);
10126impl SubmitFlagBits {
10127 pub const fn from_raw(value: u32) -> Self {
10128 Self(value)
10129 }
10130
10131 pub const fn as_raw(self) -> u32 {
10132 self.0
10133 }
10134
10135 pub const fn empty() -> Self {
10136 Self(0)
10137 }
10138
10139 pub const PROTECTED_BIT: Self = Self(1);
10140 pub const PROTECTED_BIT_KHR: Self = Self(1);
10141}
10142
10143impl std::ops::BitOr for SubmitFlagBits {
10144 type Output = Self;
10145 fn bitor(self, rhs: Self) -> Self {
10146 Self(self.0 | rhs.0)
10147 }
10148}
10149
10150impl std::ops::BitAnd for SubmitFlagBits {
10151 type Output = Self;
10152 fn bitand(self, rhs: Self) -> Self {
10153 Self(self.0 & rhs.0)
10154 }
10155}
10156
10157impl std::ops::BitXor for SubmitFlagBits {
10158 type Output = Self;
10159 fn bitxor(self, rhs: Self) -> Self {
10160 Self(self.0 ^ rhs.0)
10161 }
10162}
10163
10164impl std::ops::Not for SubmitFlagBits {
10165 type Output = Self;
10166 fn not(self) -> Self {
10167 Self(!self.0)
10168 }
10169}
10170
10171#[repr(transparent)]
10172#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10173pub struct EventCreateFlagBits(pub u32);
10174impl EventCreateFlagBits {
10175 pub const fn from_raw(value: u32) -> Self {
10176 Self(value)
10177 }
10178
10179 pub const fn as_raw(self) -> u32 {
10180 self.0
10181 }
10182
10183 pub const fn empty() -> Self {
10184 Self(0)
10185 }
10186
10187 pub const DEVICE_ONLY_BIT: Self = Self(1);
10188 pub const DEVICE_ONLY_BIT_KHR: Self = Self(1);
10189}
10190
10191impl std::ops::BitOr for EventCreateFlagBits {
10192 type Output = Self;
10193 fn bitor(self, rhs: Self) -> Self {
10194 Self(self.0 | rhs.0)
10195 }
10196}
10197
10198impl std::ops::BitAnd for EventCreateFlagBits {
10199 type Output = Self;
10200 fn bitand(self, rhs: Self) -> Self {
10201 Self(self.0 & rhs.0)
10202 }
10203}
10204
10205impl std::ops::BitXor for EventCreateFlagBits {
10206 type Output = Self;
10207 fn bitxor(self, rhs: Self) -> Self {
10208 Self(self.0 ^ rhs.0)
10209 }
10210}
10211
10212impl std::ops::Not for EventCreateFlagBits {
10213 type Output = Self;
10214 fn not(self) -> Self {
10215 Self(!self.0)
10216 }
10217}
10218
10219#[repr(transparent)]
10220#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10221pub struct PipelineLayoutCreateFlagBits(pub u32);
10222impl PipelineLayoutCreateFlagBits {
10223 pub const fn from_raw(value: u32) -> Self {
10224 Self(value)
10225 }
10226
10227 pub const fn as_raw(self) -> u32 {
10228 self.0
10229 }
10230
10231 pub const fn empty() -> Self {
10232 Self(0)
10233 }
10234
10235 pub const INDEPENDENT_SETS_BIT_EXT: Self = Self(2);
10236 pub const NO_TASK_SHADER_BIT_KHR: Self = Self(4);
10237}
10238
10239impl std::ops::BitOr for PipelineLayoutCreateFlagBits {
10240 type Output = Self;
10241 fn bitor(self, rhs: Self) -> Self {
10242 Self(self.0 | rhs.0)
10243 }
10244}
10245
10246impl std::ops::BitAnd for PipelineLayoutCreateFlagBits {
10247 type Output = Self;
10248 fn bitand(self, rhs: Self) -> Self {
10249 Self(self.0 & rhs.0)
10250 }
10251}
10252
10253impl std::ops::BitXor for PipelineLayoutCreateFlagBits {
10254 type Output = Self;
10255 fn bitxor(self, rhs: Self) -> Self {
10256 Self(self.0 ^ rhs.0)
10257 }
10258}
10259
10260impl std::ops::Not for PipelineLayoutCreateFlagBits {
10261 type Output = Self;
10262 fn not(self) -> Self {
10263 Self(!self.0)
10264 }
10265}
10266
10267#[repr(transparent)]
10268#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10269pub struct ProvokingVertexModeEXT(pub i32);
10270impl ProvokingVertexModeEXT {
10271 pub const fn from_raw(value: i32) -> Self {
10272 Self(value)
10273 }
10274
10275 pub const fn as_raw(self) -> i32 {
10276 self.0
10277 }
10278
10279 pub const fn empty() -> Self {
10280 Self(0)
10281 }
10282
10283 pub const FIRST_VERTEX_EXT: Self = Self(0);
10284 pub const LAST_VERTEX_EXT: Self = Self(1);
10285}
10286
10287#[repr(transparent)]
10288#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10289pub struct AccelerationStructureMotionInstanceTypeNV(pub i32);
10290impl AccelerationStructureMotionInstanceTypeNV {
10291 pub const fn from_raw(value: i32) -> Self {
10292 Self(value)
10293 }
10294
10295 pub const fn as_raw(self) -> i32 {
10296 self.0
10297 }
10298
10299 pub const fn empty() -> Self {
10300 Self(0)
10301 }
10302
10303 pub const STATIC_NV: Self = Self(0);
10304 pub const MATRIX_MOTION_NV: Self = Self(1);
10305 pub const SRT_MOTION_NV: Self = Self(2);
10306}
10307
10308#[repr(transparent)]
10309#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10310pub struct PipelineColorBlendStateCreateFlagBits(pub u32);
10311impl PipelineColorBlendStateCreateFlagBits {
10312 pub const fn from_raw(value: u32) -> Self {
10313 Self(value)
10314 }
10315
10316 pub const fn as_raw(self) -> u32 {
10317 self.0
10318 }
10319
10320 pub const fn empty() -> Self {
10321 Self(0)
10322 }
10323
10324 pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM: Self = Self(1);
10325 pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT: Self = Self(1);
10326}
10327
10328impl std::ops::BitOr for PipelineColorBlendStateCreateFlagBits {
10329 type Output = Self;
10330 fn bitor(self, rhs: Self) -> Self {
10331 Self(self.0 | rhs.0)
10332 }
10333}
10334
10335impl std::ops::BitAnd for PipelineColorBlendStateCreateFlagBits {
10336 type Output = Self;
10337 fn bitand(self, rhs: Self) -> Self {
10338 Self(self.0 & rhs.0)
10339 }
10340}
10341
10342impl std::ops::BitXor for PipelineColorBlendStateCreateFlagBits {
10343 type Output = Self;
10344 fn bitxor(self, rhs: Self) -> Self {
10345 Self(self.0 ^ rhs.0)
10346 }
10347}
10348
10349impl std::ops::Not for PipelineColorBlendStateCreateFlagBits {
10350 type Output = Self;
10351 fn not(self) -> Self {
10352 Self(!self.0)
10353 }
10354}
10355
10356#[repr(transparent)]
10357#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10358pub struct PipelineDepthStencilStateCreateFlagBits(pub u32);
10359impl PipelineDepthStencilStateCreateFlagBits {
10360 pub const fn from_raw(value: u32) -> Self {
10361 Self(value)
10362 }
10363
10364 pub const fn as_raw(self) -> u32 {
10365 self.0
10366 }
10367
10368 pub const fn empty() -> Self {
10369 Self(0)
10370 }
10371
10372 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: Self = Self(1);
10373 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: Self = Self(2);
10374 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: Self = Self(1);
10375 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: Self = Self(2);
10376}
10377
10378impl std::ops::BitOr for PipelineDepthStencilStateCreateFlagBits {
10379 type Output = Self;
10380 fn bitor(self, rhs: Self) -> Self {
10381 Self(self.0 | rhs.0)
10382 }
10383}
10384
10385impl std::ops::BitAnd for PipelineDepthStencilStateCreateFlagBits {
10386 type Output = Self;
10387 fn bitand(self, rhs: Self) -> Self {
10388 Self(self.0 & rhs.0)
10389 }
10390}
10391
10392impl std::ops::BitXor for PipelineDepthStencilStateCreateFlagBits {
10393 type Output = Self;
10394 fn bitxor(self, rhs: Self) -> Self {
10395 Self(self.0 ^ rhs.0)
10396 }
10397}
10398
10399impl std::ops::Not for PipelineDepthStencilStateCreateFlagBits {
10400 type Output = Self;
10401 fn not(self) -> Self {
10402 Self(!self.0)
10403 }
10404}
10405
10406#[repr(transparent)]
10407#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10408pub struct GraphicsPipelineLibraryFlagBitsEXT(pub u32);
10409impl GraphicsPipelineLibraryFlagBitsEXT {
10410 pub const fn from_raw(value: u32) -> Self {
10411 Self(value)
10412 }
10413
10414 pub const fn as_raw(self) -> u32 {
10415 self.0
10416 }
10417
10418 pub const fn empty() -> Self {
10419 Self(0)
10420 }
10421
10422 pub const VERTEX_INPUT_INTERFACE_BIT_EXT: Self = Self(1);
10423 pub const PRE_RASTERIZATION_SHADERS_BIT_EXT: Self = Self(2);
10424 pub const FRAGMENT_SHADER_BIT_EXT: Self = Self(4);
10425 pub const FRAGMENT_OUTPUT_INTERFACE_BIT_EXT: Self = Self(8);
10426}
10427
10428impl std::ops::BitOr for GraphicsPipelineLibraryFlagBitsEXT {
10429 type Output = Self;
10430 fn bitor(self, rhs: Self) -> Self {
10431 Self(self.0 | rhs.0)
10432 }
10433}
10434
10435impl std::ops::BitAnd for GraphicsPipelineLibraryFlagBitsEXT {
10436 type Output = Self;
10437 fn bitand(self, rhs: Self) -> Self {
10438 Self(self.0 & rhs.0)
10439 }
10440}
10441
10442impl std::ops::BitXor for GraphicsPipelineLibraryFlagBitsEXT {
10443 type Output = Self;
10444 fn bitxor(self, rhs: Self) -> Self {
10445 Self(self.0 ^ rhs.0)
10446 }
10447}
10448
10449impl std::ops::Not for GraphicsPipelineLibraryFlagBitsEXT {
10450 type Output = Self;
10451 fn not(self) -> Self {
10452 Self(!self.0)
10453 }
10454}
10455
10456#[repr(transparent)]
10457#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10458pub struct RenderingAttachmentFlagBitsKHR(pub u32);
10459impl RenderingAttachmentFlagBitsKHR {
10460 pub const fn from_raw(value: u32) -> Self {
10461 Self(value)
10462 }
10463
10464 pub const fn as_raw(self) -> u32 {
10465 self.0
10466 }
10467
10468 pub const fn empty() -> Self {
10469 Self(0)
10470 }
10471
10472 pub const INPUT_ATTACHMENT_FEEDBACK_BIT_KHR: Self = Self(1);
10473 pub const RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: Self = Self(2);
10474 pub const RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: Self = Self(4);
10475}
10476
10477impl std::ops::BitOr for RenderingAttachmentFlagBitsKHR {
10478 type Output = Self;
10479 fn bitor(self, rhs: Self) -> Self {
10480 Self(self.0 | rhs.0)
10481 }
10482}
10483
10484impl std::ops::BitAnd for RenderingAttachmentFlagBitsKHR {
10485 type Output = Self;
10486 fn bitand(self, rhs: Self) -> Self {
10487 Self(self.0 & rhs.0)
10488 }
10489}
10490
10491impl std::ops::BitXor for RenderingAttachmentFlagBitsKHR {
10492 type Output = Self;
10493 fn bitxor(self, rhs: Self) -> Self {
10494 Self(self.0 ^ rhs.0)
10495 }
10496}
10497
10498impl std::ops::Not for RenderingAttachmentFlagBitsKHR {
10499 type Output = Self;
10500 fn not(self) -> Self {
10501 Self(!self.0)
10502 }
10503}
10504
10505#[repr(transparent)]
10506#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10507pub struct ResolveImageFlagBitsKHR(pub u32);
10508impl ResolveImageFlagBitsKHR {
10509 pub const fn from_raw(value: u32) -> Self {
10510 Self(value)
10511 }
10512
10513 pub const fn as_raw(self) -> u32 {
10514 self.0
10515 }
10516
10517 pub const fn empty() -> Self {
10518 Self(0)
10519 }
10520
10521 pub const SKIP_TRANSFER_FUNCTION_BIT_KHR: Self = Self(1);
10522 pub const ENABLE_TRANSFER_FUNCTION_BIT_KHR: Self = Self(2);
10523}
10524
10525impl std::ops::BitOr for ResolveImageFlagBitsKHR {
10526 type Output = Self;
10527 fn bitor(self, rhs: Self) -> Self {
10528 Self(self.0 | rhs.0)
10529 }
10530}
10531
10532impl std::ops::BitAnd for ResolveImageFlagBitsKHR {
10533 type Output = Self;
10534 fn bitand(self, rhs: Self) -> Self {
10535 Self(self.0 & rhs.0)
10536 }
10537}
10538
10539impl std::ops::BitXor for ResolveImageFlagBitsKHR {
10540 type Output = Self;
10541 fn bitxor(self, rhs: Self) -> Self {
10542 Self(self.0 ^ rhs.0)
10543 }
10544}
10545
10546impl std::ops::Not for ResolveImageFlagBitsKHR {
10547 type Output = Self;
10548 fn not(self) -> Self {
10549 Self(!self.0)
10550 }
10551}
10552
10553#[repr(transparent)]
10554#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10555pub struct DeviceAddressBindingFlagBitsEXT(pub u32);
10556impl DeviceAddressBindingFlagBitsEXT {
10557 pub const fn from_raw(value: u32) -> Self {
10558 Self(value)
10559 }
10560
10561 pub const fn as_raw(self) -> u32 {
10562 self.0
10563 }
10564
10565 pub const fn empty() -> Self {
10566 Self(0)
10567 }
10568
10569 pub const INTERNAL_OBJECT_BIT_EXT: Self = Self(1);
10570}
10571
10572impl std::ops::BitOr for DeviceAddressBindingFlagBitsEXT {
10573 type Output = Self;
10574 fn bitor(self, rhs: Self) -> Self {
10575 Self(self.0 | rhs.0)
10576 }
10577}
10578
10579impl std::ops::BitAnd for DeviceAddressBindingFlagBitsEXT {
10580 type Output = Self;
10581 fn bitand(self, rhs: Self) -> Self {
10582 Self(self.0 & rhs.0)
10583 }
10584}
10585
10586impl std::ops::BitXor for DeviceAddressBindingFlagBitsEXT {
10587 type Output = Self;
10588 fn bitxor(self, rhs: Self) -> Self {
10589 Self(self.0 ^ rhs.0)
10590 }
10591}
10592
10593impl std::ops::Not for DeviceAddressBindingFlagBitsEXT {
10594 type Output = Self;
10595 fn not(self) -> Self {
10596 Self(!self.0)
10597 }
10598}
10599
10600#[repr(transparent)]
10601#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10602pub struct DeviceAddressBindingTypeEXT(pub i32);
10603impl DeviceAddressBindingTypeEXT {
10604 pub const fn from_raw(value: i32) -> Self {
10605 Self(value)
10606 }
10607
10608 pub const fn as_raw(self) -> i32 {
10609 self.0
10610 }
10611
10612 pub const fn empty() -> Self {
10613 Self(0)
10614 }
10615
10616 pub const BIND_EXT: Self = Self(0);
10617 pub const UNBIND_EXT: Self = Self(1);
10618}
10619
10620#[repr(transparent)]
10621#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10622pub struct FrameBoundaryFlagBitsEXT(pub u32);
10623impl FrameBoundaryFlagBitsEXT {
10624 pub const fn from_raw(value: u32) -> Self {
10625 Self(value)
10626 }
10627
10628 pub const fn as_raw(self) -> u32 {
10629 self.0
10630 }
10631
10632 pub const fn empty() -> Self {
10633 Self(0)
10634 }
10635
10636 pub const FRAME_END_BIT_EXT: Self = Self(1);
10637}
10638
10639impl std::ops::BitOr for FrameBoundaryFlagBitsEXT {
10640 type Output = Self;
10641 fn bitor(self, rhs: Self) -> Self {
10642 Self(self.0 | rhs.0)
10643 }
10644}
10645
10646impl std::ops::BitAnd for FrameBoundaryFlagBitsEXT {
10647 type Output = Self;
10648 fn bitand(self, rhs: Self) -> Self {
10649 Self(self.0 & rhs.0)
10650 }
10651}
10652
10653impl std::ops::BitXor for FrameBoundaryFlagBitsEXT {
10654 type Output = Self;
10655 fn bitxor(self, rhs: Self) -> Self {
10656 Self(self.0 ^ rhs.0)
10657 }
10658}
10659
10660impl std::ops::Not for FrameBoundaryFlagBitsEXT {
10661 type Output = Self;
10662 fn not(self) -> Self {
10663 Self(!self.0)
10664 }
10665}
10666
10667#[repr(transparent)]
10668#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10669pub struct PresentScalingFlagBitsKHR(pub u32);
10670impl PresentScalingFlagBitsKHR {
10671 pub const fn from_raw(value: u32) -> Self {
10672 Self(value)
10673 }
10674
10675 pub const fn as_raw(self) -> u32 {
10676 self.0
10677 }
10678
10679 pub const fn empty() -> Self {
10680 Self(0)
10681 }
10682
10683 pub const ONE_TO_ONE_BIT_KHR: Self = Self(1);
10684 pub const ONE_TO_ONE_BIT_EXT: Self = Self(1);
10685 pub const ASPECT_RATIO_STRETCH_BIT_KHR: Self = Self(2);
10686 pub const ASPECT_RATIO_STRETCH_BIT_EXT: Self = Self(2);
10687 pub const STRETCH_BIT_KHR: Self = Self(4);
10688 pub const STRETCH_BIT_EXT: Self = Self(4);
10689}
10690
10691impl std::ops::BitOr for PresentScalingFlagBitsKHR {
10692 type Output = Self;
10693 fn bitor(self, rhs: Self) -> Self {
10694 Self(self.0 | rhs.0)
10695 }
10696}
10697
10698impl std::ops::BitAnd for PresentScalingFlagBitsKHR {
10699 type Output = Self;
10700 fn bitand(self, rhs: Self) -> Self {
10701 Self(self.0 & rhs.0)
10702 }
10703}
10704
10705impl std::ops::BitXor for PresentScalingFlagBitsKHR {
10706 type Output = Self;
10707 fn bitxor(self, rhs: Self) -> Self {
10708 Self(self.0 ^ rhs.0)
10709 }
10710}
10711
10712impl std::ops::Not for PresentScalingFlagBitsKHR {
10713 type Output = Self;
10714 fn not(self) -> Self {
10715 Self(!self.0)
10716 }
10717}
10718
10719#[repr(transparent)]
10720#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10721pub struct PresentGravityFlagBitsKHR(pub u32);
10722impl PresentGravityFlagBitsKHR {
10723 pub const fn from_raw(value: u32) -> Self {
10724 Self(value)
10725 }
10726
10727 pub const fn as_raw(self) -> u32 {
10728 self.0
10729 }
10730
10731 pub const fn empty() -> Self {
10732 Self(0)
10733 }
10734
10735 pub const MIN_BIT_KHR: Self = Self(1);
10736 pub const MIN_BIT_EXT: Self = Self(1);
10737 pub const MAX_BIT_KHR: Self = Self(2);
10738 pub const MAX_BIT_EXT: Self = Self(2);
10739 pub const CENTERED_BIT_KHR: Self = Self(4);
10740 pub const CENTERED_BIT_EXT: Self = Self(4);
10741}
10742
10743impl std::ops::BitOr for PresentGravityFlagBitsKHR {
10744 type Output = Self;
10745 fn bitor(self, rhs: Self) -> Self {
10746 Self(self.0 | rhs.0)
10747 }
10748}
10749
10750impl std::ops::BitAnd for PresentGravityFlagBitsKHR {
10751 type Output = Self;
10752 fn bitand(self, rhs: Self) -> Self {
10753 Self(self.0 & rhs.0)
10754 }
10755}
10756
10757impl std::ops::BitXor for PresentGravityFlagBitsKHR {
10758 type Output = Self;
10759 fn bitxor(self, rhs: Self) -> Self {
10760 Self(self.0 ^ rhs.0)
10761 }
10762}
10763
10764impl std::ops::Not for PresentGravityFlagBitsKHR {
10765 type Output = Self;
10766 fn not(self) -> Self {
10767 Self(!self.0)
10768 }
10769}
10770
10771#[repr(transparent)]
10772#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10773pub struct PhysicalDeviceSchedulingControlsFlagBitsARM(pub u64);
10774impl PhysicalDeviceSchedulingControlsFlagBitsARM {
10775 pub const fn from_raw(value: u64) -> Self {
10776 Self(value)
10777 }
10778
10779 pub const fn as_raw(self) -> u64 {
10780 self.0
10781 }
10782
10783 pub const fn empty() -> Self {
10784 Self(0)
10785 }
10786
10787 pub const SHADER_CORE_COUNT_ARM: Self = Self(1);
10788 pub const DISPATCH_PARAMETERS_ARM: Self = Self(2);
10789}
10790
10791impl std::ops::BitOr for PhysicalDeviceSchedulingControlsFlagBitsARM {
10792 type Output = Self;
10793 fn bitor(self, rhs: Self) -> Self {
10794 Self(self.0 | rhs.0)
10795 }
10796}
10797
10798impl std::ops::BitAnd for PhysicalDeviceSchedulingControlsFlagBitsARM {
10799 type Output = Self;
10800 fn bitand(self, rhs: Self) -> Self {
10801 Self(self.0 & rhs.0)
10802 }
10803}
10804
10805impl std::ops::BitXor for PhysicalDeviceSchedulingControlsFlagBitsARM {
10806 type Output = Self;
10807 fn bitxor(self, rhs: Self) -> Self {
10808 Self(self.0 ^ rhs.0)
10809 }
10810}
10811
10812impl std::ops::Not for PhysicalDeviceSchedulingControlsFlagBitsARM {
10813 type Output = Self;
10814 fn not(self) -> Self {
10815 Self(!self.0)
10816 }
10817}
10818
10819#[repr(transparent)]
10820#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10821pub struct PresentStageFlagBitsEXT(pub u32);
10822impl PresentStageFlagBitsEXT {
10823 pub const fn from_raw(value: u32) -> Self {
10824 Self(value)
10825 }
10826
10827 pub const fn as_raw(self) -> u32 {
10828 self.0
10829 }
10830
10831 pub const fn empty() -> Self {
10832 Self(0)
10833 }
10834
10835 pub const QUEUE_OPERATIONS_END_BIT_EXT: Self = Self(1);
10836 pub const REQUEST_DEQUEUED_BIT_EXT: Self = Self(2);
10837 pub const IMAGE_FIRST_PIXEL_OUT_BIT_EXT: Self = Self(4);
10838 pub const IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT: Self = Self(8);
10839}
10840
10841impl std::ops::BitOr for PresentStageFlagBitsEXT {
10842 type Output = Self;
10843 fn bitor(self, rhs: Self) -> Self {
10844 Self(self.0 | rhs.0)
10845 }
10846}
10847
10848impl std::ops::BitAnd for PresentStageFlagBitsEXT {
10849 type Output = Self;
10850 fn bitand(self, rhs: Self) -> Self {
10851 Self(self.0 & rhs.0)
10852 }
10853}
10854
10855impl std::ops::BitXor for PresentStageFlagBitsEXT {
10856 type Output = Self;
10857 fn bitxor(self, rhs: Self) -> Self {
10858 Self(self.0 ^ rhs.0)
10859 }
10860}
10861
10862impl std::ops::Not for PresentStageFlagBitsEXT {
10863 type Output = Self;
10864 fn not(self) -> Self {
10865 Self(!self.0)
10866 }
10867}
10868
10869#[repr(transparent)]
10870#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10871pub struct PastPresentationTimingFlagBitsEXT(pub u32);
10872impl PastPresentationTimingFlagBitsEXT {
10873 pub const fn from_raw(value: u32) -> Self {
10874 Self(value)
10875 }
10876
10877 pub const fn as_raw(self) -> u32 {
10878 self.0
10879 }
10880
10881 pub const fn empty() -> Self {
10882 Self(0)
10883 }
10884
10885 pub const ALLOW_PARTIAL_RESULTS_BIT_EXT: Self = Self(1);
10886 pub const ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT: Self = Self(2);
10887}
10888
10889impl std::ops::BitOr for PastPresentationTimingFlagBitsEXT {
10890 type Output = Self;
10891 fn bitor(self, rhs: Self) -> Self {
10892 Self(self.0 | rhs.0)
10893 }
10894}
10895
10896impl std::ops::BitAnd for PastPresentationTimingFlagBitsEXT {
10897 type Output = Self;
10898 fn bitand(self, rhs: Self) -> Self {
10899 Self(self.0 & rhs.0)
10900 }
10901}
10902
10903impl std::ops::BitXor for PastPresentationTimingFlagBitsEXT {
10904 type Output = Self;
10905 fn bitxor(self, rhs: Self) -> Self {
10906 Self(self.0 ^ rhs.0)
10907 }
10908}
10909
10910impl std::ops::Not for PastPresentationTimingFlagBitsEXT {
10911 type Output = Self;
10912 fn not(self) -> Self {
10913 Self(!self.0)
10914 }
10915}
10916
10917#[repr(transparent)]
10918#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10919pub struct PresentTimingInfoFlagBitsEXT(pub u32);
10920impl PresentTimingInfoFlagBitsEXT {
10921 pub const fn from_raw(value: u32) -> Self {
10922 Self(value)
10923 }
10924
10925 pub const fn as_raw(self) -> u32 {
10926 self.0
10927 }
10928
10929 pub const fn empty() -> Self {
10930 Self(0)
10931 }
10932
10933 pub const PRESENT_AT_RELATIVE_TIME_BIT_EXT: Self = Self(1);
10934 pub const PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT: Self = Self(2);
10935}
10936
10937impl std::ops::BitOr for PresentTimingInfoFlagBitsEXT {
10938 type Output = Self;
10939 fn bitor(self, rhs: Self) -> Self {
10940 Self(self.0 | rhs.0)
10941 }
10942}
10943
10944impl std::ops::BitAnd for PresentTimingInfoFlagBitsEXT {
10945 type Output = Self;
10946 fn bitand(self, rhs: Self) -> Self {
10947 Self(self.0 & rhs.0)
10948 }
10949}
10950
10951impl std::ops::BitXor for PresentTimingInfoFlagBitsEXT {
10952 type Output = Self;
10953 fn bitxor(self, rhs: Self) -> Self {
10954 Self(self.0 ^ rhs.0)
10955 }
10956}
10957
10958impl std::ops::Not for PresentTimingInfoFlagBitsEXT {
10959 type Output = Self;
10960 fn not(self) -> Self {
10961 Self(!self.0)
10962 }
10963}
10964
10965#[repr(transparent)]
10966#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
10967pub struct VideoCodecOperationFlagBitsKHR(pub u32);
10968impl VideoCodecOperationFlagBitsKHR {
10969 pub const fn from_raw(value: u32) -> Self {
10970 Self(value)
10971 }
10972
10973 pub const fn as_raw(self) -> u32 {
10974 self.0
10975 }
10976
10977 pub const fn empty() -> Self {
10978 Self(0)
10979 }
10980
10981 pub const NONE_KHR: Self = Self(0);
10982 pub const ENCODE_H264_BIT_KHR: Self = Self(65536);
10983 pub const ENCODE_H265_BIT_KHR: Self = Self(131072);
10984 pub const DECODE_H264_BIT_KHR: Self = Self(1);
10985 pub const DECODE_H265_BIT_KHR: Self = Self(2);
10986 pub const DECODE_AV1_BIT_KHR: Self = Self(4);
10987 pub const ENCODE_AV1_BIT_KHR: Self = Self(262144);
10988 pub const DECODE_VP9_BIT_KHR: Self = Self(8);
10989}
10990
10991impl std::ops::BitOr for VideoCodecOperationFlagBitsKHR {
10992 type Output = Self;
10993 fn bitor(self, rhs: Self) -> Self {
10994 Self(self.0 | rhs.0)
10995 }
10996}
10997
10998impl std::ops::BitAnd for VideoCodecOperationFlagBitsKHR {
10999 type Output = Self;
11000 fn bitand(self, rhs: Self) -> Self {
11001 Self(self.0 & rhs.0)
11002 }
11003}
11004
11005impl std::ops::BitXor for VideoCodecOperationFlagBitsKHR {
11006 type Output = Self;
11007 fn bitxor(self, rhs: Self) -> Self {
11008 Self(self.0 ^ rhs.0)
11009 }
11010}
11011
11012impl std::ops::Not for VideoCodecOperationFlagBitsKHR {
11013 type Output = Self;
11014 fn not(self) -> Self {
11015 Self(!self.0)
11016 }
11017}
11018
11019#[repr(transparent)]
11020#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11021pub struct VideoChromaSubsamplingFlagBitsKHR(pub u32);
11022impl VideoChromaSubsamplingFlagBitsKHR {
11023 pub const fn from_raw(value: u32) -> Self {
11024 Self(value)
11025 }
11026
11027 pub const fn as_raw(self) -> u32 {
11028 self.0
11029 }
11030
11031 pub const fn empty() -> Self {
11032 Self(0)
11033 }
11034
11035 pub const INVALID_KHR: Self = Self(0);
11036 pub const MONOCHROME_BIT_KHR: Self = Self(1);
11037 pub const _420_BIT_KHR: Self = Self(2);
11038 pub const _422_BIT_KHR: Self = Self(4);
11039 pub const _444_BIT_KHR: Self = Self(8);
11040}
11041
11042impl std::ops::BitOr for VideoChromaSubsamplingFlagBitsKHR {
11043 type Output = Self;
11044 fn bitor(self, rhs: Self) -> Self {
11045 Self(self.0 | rhs.0)
11046 }
11047}
11048
11049impl std::ops::BitAnd for VideoChromaSubsamplingFlagBitsKHR {
11050 type Output = Self;
11051 fn bitand(self, rhs: Self) -> Self {
11052 Self(self.0 & rhs.0)
11053 }
11054}
11055
11056impl std::ops::BitXor for VideoChromaSubsamplingFlagBitsKHR {
11057 type Output = Self;
11058 fn bitxor(self, rhs: Self) -> Self {
11059 Self(self.0 ^ rhs.0)
11060 }
11061}
11062
11063impl std::ops::Not for VideoChromaSubsamplingFlagBitsKHR {
11064 type Output = Self;
11065 fn not(self) -> Self {
11066 Self(!self.0)
11067 }
11068}
11069
11070#[repr(transparent)]
11071#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11072pub struct VideoComponentBitDepthFlagBitsKHR(pub u32);
11073impl VideoComponentBitDepthFlagBitsKHR {
11074 pub const fn from_raw(value: u32) -> Self {
11075 Self(value)
11076 }
11077
11078 pub const fn as_raw(self) -> u32 {
11079 self.0
11080 }
11081
11082 pub const fn empty() -> Self {
11083 Self(0)
11084 }
11085
11086 pub const INVALID_KHR: Self = Self(0);
11087 pub const _8_BIT_KHR: Self = Self(1);
11088 pub const _10_BIT_KHR: Self = Self(4);
11089 pub const _12_BIT_KHR: Self = Self(16);
11090}
11091
11092impl std::ops::BitOr for VideoComponentBitDepthFlagBitsKHR {
11093 type Output = Self;
11094 fn bitor(self, rhs: Self) -> Self {
11095 Self(self.0 | rhs.0)
11096 }
11097}
11098
11099impl std::ops::BitAnd for VideoComponentBitDepthFlagBitsKHR {
11100 type Output = Self;
11101 fn bitand(self, rhs: Self) -> Self {
11102 Self(self.0 & rhs.0)
11103 }
11104}
11105
11106impl std::ops::BitXor for VideoComponentBitDepthFlagBitsKHR {
11107 type Output = Self;
11108 fn bitxor(self, rhs: Self) -> Self {
11109 Self(self.0 ^ rhs.0)
11110 }
11111}
11112
11113impl std::ops::Not for VideoComponentBitDepthFlagBitsKHR {
11114 type Output = Self;
11115 fn not(self) -> Self {
11116 Self(!self.0)
11117 }
11118}
11119
11120#[repr(transparent)]
11121#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11122pub struct VideoCapabilityFlagBitsKHR(pub u32);
11123impl VideoCapabilityFlagBitsKHR {
11124 pub const fn from_raw(value: u32) -> Self {
11125 Self(value)
11126 }
11127
11128 pub const fn as_raw(self) -> u32 {
11129 self.0
11130 }
11131
11132 pub const fn empty() -> Self {
11133 Self(0)
11134 }
11135
11136 pub const PROTECTED_CONTENT_BIT_KHR: Self = Self(1);
11137 pub const SEPARATE_REFERENCE_IMAGES_BIT_KHR: Self = Self(2);
11138}
11139
11140impl std::ops::BitOr for VideoCapabilityFlagBitsKHR {
11141 type Output = Self;
11142 fn bitor(self, rhs: Self) -> Self {
11143 Self(self.0 | rhs.0)
11144 }
11145}
11146
11147impl std::ops::BitAnd for VideoCapabilityFlagBitsKHR {
11148 type Output = Self;
11149 fn bitand(self, rhs: Self) -> Self {
11150 Self(self.0 & rhs.0)
11151 }
11152}
11153
11154impl std::ops::BitXor for VideoCapabilityFlagBitsKHR {
11155 type Output = Self;
11156 fn bitxor(self, rhs: Self) -> Self {
11157 Self(self.0 ^ rhs.0)
11158 }
11159}
11160
11161impl std::ops::Not for VideoCapabilityFlagBitsKHR {
11162 type Output = Self;
11163 fn not(self) -> Self {
11164 Self(!self.0)
11165 }
11166}
11167
11168#[repr(transparent)]
11169#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11170pub struct VideoSessionCreateFlagBitsKHR(pub u32);
11171impl VideoSessionCreateFlagBitsKHR {
11172 pub const fn from_raw(value: u32) -> Self {
11173 Self(value)
11174 }
11175
11176 pub const fn as_raw(self) -> u32 {
11177 self.0
11178 }
11179
11180 pub const fn empty() -> Self {
11181 Self(0)
11182 }
11183
11184 pub const PROTECTED_CONTENT_BIT_KHR: Self = Self(1);
11185 pub const ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR: Self = Self(2);
11186 pub const INLINE_QUERIES_BIT_KHR: Self = Self(4);
11187 pub const ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: Self = Self(8);
11188 pub const ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR: Self = Self(16);
11189 pub const INLINE_SESSION_PARAMETERS_BIT_KHR: Self = Self(32);
11190}
11191
11192impl std::ops::BitOr for VideoSessionCreateFlagBitsKHR {
11193 type Output = Self;
11194 fn bitor(self, rhs: Self) -> Self {
11195 Self(self.0 | rhs.0)
11196 }
11197}
11198
11199impl std::ops::BitAnd for VideoSessionCreateFlagBitsKHR {
11200 type Output = Self;
11201 fn bitand(self, rhs: Self) -> Self {
11202 Self(self.0 & rhs.0)
11203 }
11204}
11205
11206impl std::ops::BitXor for VideoSessionCreateFlagBitsKHR {
11207 type Output = Self;
11208 fn bitxor(self, rhs: Self) -> Self {
11209 Self(self.0 ^ rhs.0)
11210 }
11211}
11212
11213impl std::ops::Not for VideoSessionCreateFlagBitsKHR {
11214 type Output = Self;
11215 fn not(self) -> Self {
11216 Self(!self.0)
11217 }
11218}
11219
11220#[repr(transparent)]
11221#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11222pub struct VideoSessionParametersCreateFlagBitsKHR(pub u32);
11223impl VideoSessionParametersCreateFlagBitsKHR {
11224 pub const fn from_raw(value: u32) -> Self {
11225 Self(value)
11226 }
11227
11228 pub const fn as_raw(self) -> u32 {
11229 self.0
11230 }
11231
11232 pub const fn empty() -> Self {
11233 Self(0)
11234 }
11235
11236 pub const QUANTIZATION_MAP_COMPATIBLE_BIT_KHR: Self = Self(1);
11237}
11238
11239impl std::ops::BitOr for VideoSessionParametersCreateFlagBitsKHR {
11240 type Output = Self;
11241 fn bitor(self, rhs: Self) -> Self {
11242 Self(self.0 | rhs.0)
11243 }
11244}
11245
11246impl std::ops::BitAnd for VideoSessionParametersCreateFlagBitsKHR {
11247 type Output = Self;
11248 fn bitand(self, rhs: Self) -> Self {
11249 Self(self.0 & rhs.0)
11250 }
11251}
11252
11253impl std::ops::BitXor for VideoSessionParametersCreateFlagBitsKHR {
11254 type Output = Self;
11255 fn bitxor(self, rhs: Self) -> Self {
11256 Self(self.0 ^ rhs.0)
11257 }
11258}
11259
11260impl std::ops::Not for VideoSessionParametersCreateFlagBitsKHR {
11261 type Output = Self;
11262 fn not(self) -> Self {
11263 Self(!self.0)
11264 }
11265}
11266
11267#[repr(transparent)]
11268#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11269pub struct VideoDecodeH264PictureLayoutFlagBitsKHR(pub u32);
11270impl VideoDecodeH264PictureLayoutFlagBitsKHR {
11271 pub const fn from_raw(value: u32) -> Self {
11272 Self(value)
11273 }
11274
11275 pub const fn as_raw(self) -> u32 {
11276 self.0
11277 }
11278
11279 pub const fn empty() -> Self {
11280 Self(0)
11281 }
11282
11283 pub const PROGRESSIVE_KHR: Self = Self(0);
11284 pub const INTERLACED_INTERLEAVED_LINES_BIT_KHR: Self = Self(1);
11285 pub const INTERLACED_SEPARATE_PLANES_BIT_KHR: Self = Self(2);
11286}
11287
11288impl std::ops::BitOr for VideoDecodeH264PictureLayoutFlagBitsKHR {
11289 type Output = Self;
11290 fn bitor(self, rhs: Self) -> Self {
11291 Self(self.0 | rhs.0)
11292 }
11293}
11294
11295impl std::ops::BitAnd for VideoDecodeH264PictureLayoutFlagBitsKHR {
11296 type Output = Self;
11297 fn bitand(self, rhs: Self) -> Self {
11298 Self(self.0 & rhs.0)
11299 }
11300}
11301
11302impl std::ops::BitXor for VideoDecodeH264PictureLayoutFlagBitsKHR {
11303 type Output = Self;
11304 fn bitxor(self, rhs: Self) -> Self {
11305 Self(self.0 ^ rhs.0)
11306 }
11307}
11308
11309impl std::ops::Not for VideoDecodeH264PictureLayoutFlagBitsKHR {
11310 type Output = Self;
11311 fn not(self) -> Self {
11312 Self(!self.0)
11313 }
11314}
11315
11316#[repr(transparent)]
11317#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11318pub struct VideoCodingControlFlagBitsKHR(pub u32);
11319impl VideoCodingControlFlagBitsKHR {
11320 pub const fn from_raw(value: u32) -> Self {
11321 Self(value)
11322 }
11323
11324 pub const fn as_raw(self) -> u32 {
11325 self.0
11326 }
11327
11328 pub const fn empty() -> Self {
11329 Self(0)
11330 }
11331
11332 pub const RESET_BIT_KHR: Self = Self(1);
11333 pub const ENCODE_RATE_CONTROL_BIT_KHR: Self = Self(2);
11334 pub const ENCODE_QUALITY_LEVEL_BIT_KHR: Self = Self(4);
11335}
11336
11337impl std::ops::BitOr for VideoCodingControlFlagBitsKHR {
11338 type Output = Self;
11339 fn bitor(self, rhs: Self) -> Self {
11340 Self(self.0 | rhs.0)
11341 }
11342}
11343
11344impl std::ops::BitAnd for VideoCodingControlFlagBitsKHR {
11345 type Output = Self;
11346 fn bitand(self, rhs: Self) -> Self {
11347 Self(self.0 & rhs.0)
11348 }
11349}
11350
11351impl std::ops::BitXor for VideoCodingControlFlagBitsKHR {
11352 type Output = Self;
11353 fn bitxor(self, rhs: Self) -> Self {
11354 Self(self.0 ^ rhs.0)
11355 }
11356}
11357
11358impl std::ops::Not for VideoCodingControlFlagBitsKHR {
11359 type Output = Self;
11360 fn not(self) -> Self {
11361 Self(!self.0)
11362 }
11363}
11364
11365#[repr(transparent)]
11366#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11367pub struct QueryResultStatusKHR(pub i32);
11368impl QueryResultStatusKHR {
11369 pub const fn from_raw(value: i32) -> Self {
11370 Self(value)
11371 }
11372
11373 pub const fn as_raw(self) -> i32 {
11374 self.0
11375 }
11376
11377 pub const fn empty() -> Self {
11378 Self(0)
11379 }
11380
11381 pub const ERROR_KHR: Self = Self(-1);
11382 pub const NOT_READY_KHR: Self = Self(0);
11383 pub const COMPLETE_KHR: Self = Self(1);
11384 pub const INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR: Self = Self(-1000299000);
11385}
11386
11387#[repr(transparent)]
11388#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11389pub struct VideoDecodeUsageFlagBitsKHR(pub u32);
11390impl VideoDecodeUsageFlagBitsKHR {
11391 pub const fn from_raw(value: u32) -> Self {
11392 Self(value)
11393 }
11394
11395 pub const fn as_raw(self) -> u32 {
11396 self.0
11397 }
11398
11399 pub const fn empty() -> Self {
11400 Self(0)
11401 }
11402
11403 pub const DEFAULT_KHR: Self = Self(0);
11404 pub const TRANSCODING_BIT_KHR: Self = Self(1);
11405 pub const OFFLINE_BIT_KHR: Self = Self(2);
11406 pub const STREAMING_BIT_KHR: Self = Self(4);
11407}
11408
11409impl std::ops::BitOr for VideoDecodeUsageFlagBitsKHR {
11410 type Output = Self;
11411 fn bitor(self, rhs: Self) -> Self {
11412 Self(self.0 | rhs.0)
11413 }
11414}
11415
11416impl std::ops::BitAnd for VideoDecodeUsageFlagBitsKHR {
11417 type Output = Self;
11418 fn bitand(self, rhs: Self) -> Self {
11419 Self(self.0 & rhs.0)
11420 }
11421}
11422
11423impl std::ops::BitXor for VideoDecodeUsageFlagBitsKHR {
11424 type Output = Self;
11425 fn bitxor(self, rhs: Self) -> Self {
11426 Self(self.0 ^ rhs.0)
11427 }
11428}
11429
11430impl std::ops::Not for VideoDecodeUsageFlagBitsKHR {
11431 type Output = Self;
11432 fn not(self) -> Self {
11433 Self(!self.0)
11434 }
11435}
11436
11437#[repr(transparent)]
11438#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11439pub struct VideoDecodeCapabilityFlagBitsKHR(pub u32);
11440impl VideoDecodeCapabilityFlagBitsKHR {
11441 pub const fn from_raw(value: u32) -> Self {
11442 Self(value)
11443 }
11444
11445 pub const fn as_raw(self) -> u32 {
11446 self.0
11447 }
11448
11449 pub const fn empty() -> Self {
11450 Self(0)
11451 }
11452
11453 pub const DPB_AND_OUTPUT_COINCIDE_BIT_KHR: Self = Self(1);
11454 pub const DPB_AND_OUTPUT_DISTINCT_BIT_KHR: Self = Self(2);
11455}
11456
11457impl std::ops::BitOr for VideoDecodeCapabilityFlagBitsKHR {
11458 type Output = Self;
11459 fn bitor(self, rhs: Self) -> Self {
11460 Self(self.0 | rhs.0)
11461 }
11462}
11463
11464impl std::ops::BitAnd for VideoDecodeCapabilityFlagBitsKHR {
11465 type Output = Self;
11466 fn bitand(self, rhs: Self) -> Self {
11467 Self(self.0 & rhs.0)
11468 }
11469}
11470
11471impl std::ops::BitXor for VideoDecodeCapabilityFlagBitsKHR {
11472 type Output = Self;
11473 fn bitxor(self, rhs: Self) -> Self {
11474 Self(self.0 ^ rhs.0)
11475 }
11476}
11477
11478impl std::ops::Not for VideoDecodeCapabilityFlagBitsKHR {
11479 type Output = Self;
11480 fn not(self) -> Self {
11481 Self(!self.0)
11482 }
11483}
11484
11485#[repr(transparent)]
11486#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11487pub struct VideoEncodeFlagBitsKHR(pub u32);
11488impl VideoEncodeFlagBitsKHR {
11489 pub const fn from_raw(value: u32) -> Self {
11490 Self(value)
11491 }
11492
11493 pub const fn as_raw(self) -> u32 {
11494 self.0
11495 }
11496
11497 pub const fn empty() -> Self {
11498 Self(0)
11499 }
11500
11501 pub const INTRA_REFRESH_BIT_KHR: Self = Self(4);
11502 pub const WITH_QUANTIZATION_DELTA_MAP_BIT_KHR: Self = Self(1);
11503 pub const WITH_EMPHASIS_MAP_BIT_KHR: Self = Self(2);
11504}
11505
11506impl std::ops::BitOr for VideoEncodeFlagBitsKHR {
11507 type Output = Self;
11508 fn bitor(self, rhs: Self) -> Self {
11509 Self(self.0 | rhs.0)
11510 }
11511}
11512
11513impl std::ops::BitAnd for VideoEncodeFlagBitsKHR {
11514 type Output = Self;
11515 fn bitand(self, rhs: Self) -> Self {
11516 Self(self.0 & rhs.0)
11517 }
11518}
11519
11520impl std::ops::BitXor for VideoEncodeFlagBitsKHR {
11521 type Output = Self;
11522 fn bitxor(self, rhs: Self) -> Self {
11523 Self(self.0 ^ rhs.0)
11524 }
11525}
11526
11527impl std::ops::Not for VideoEncodeFlagBitsKHR {
11528 type Output = Self;
11529 fn not(self) -> Self {
11530 Self(!self.0)
11531 }
11532}
11533
11534#[repr(transparent)]
11535#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11536pub struct CooperativeMatrixFlagBitsEXT(pub u32);
11537impl CooperativeMatrixFlagBitsEXT {
11538 pub const fn from_raw(value: u32) -> Self {
11539 Self(value)
11540 }
11541
11542 pub const fn as_raw(self) -> u32 {
11543 self.0
11544 }
11545
11546 pub const fn empty() -> Self {
11547 Self(0)
11548 }
11549
11550 pub const SATURATING_ACCUMULATION_BIT_EXT: Self = Self(1);
11551}
11552
11553impl std::ops::BitOr for CooperativeMatrixFlagBitsEXT {
11554 type Output = Self;
11555 fn bitor(self, rhs: Self) -> Self {
11556 Self(self.0 | rhs.0)
11557 }
11558}
11559
11560impl std::ops::BitAnd for CooperativeMatrixFlagBitsEXT {
11561 type Output = Self;
11562 fn bitand(self, rhs: Self) -> Self {
11563 Self(self.0 & rhs.0)
11564 }
11565}
11566
11567impl std::ops::BitXor for CooperativeMatrixFlagBitsEXT {
11568 type Output = Self;
11569 fn bitxor(self, rhs: Self) -> Self {
11570 Self(self.0 ^ rhs.0)
11571 }
11572}
11573
11574impl std::ops::Not for CooperativeMatrixFlagBitsEXT {
11575 type Output = Self;
11576 fn not(self) -> Self {
11577 Self(!self.0)
11578 }
11579}
11580
11581#[repr(transparent)]
11582#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11583pub struct VideoEncodeUsageFlagBitsKHR(pub u32);
11584impl VideoEncodeUsageFlagBitsKHR {
11585 pub const fn from_raw(value: u32) -> Self {
11586 Self(value)
11587 }
11588
11589 pub const fn as_raw(self) -> u32 {
11590 self.0
11591 }
11592
11593 pub const fn empty() -> Self {
11594 Self(0)
11595 }
11596
11597 pub const DEFAULT_KHR: Self = Self(0);
11598 pub const TRANSCODING_BIT_KHR: Self = Self(1);
11599 pub const STREAMING_BIT_KHR: Self = Self(2);
11600 pub const RECORDING_BIT_KHR: Self = Self(4);
11601 pub const CONFERENCING_BIT_KHR: Self = Self(8);
11602}
11603
11604impl std::ops::BitOr for VideoEncodeUsageFlagBitsKHR {
11605 type Output = Self;
11606 fn bitor(self, rhs: Self) -> Self {
11607 Self(self.0 | rhs.0)
11608 }
11609}
11610
11611impl std::ops::BitAnd for VideoEncodeUsageFlagBitsKHR {
11612 type Output = Self;
11613 fn bitand(self, rhs: Self) -> Self {
11614 Self(self.0 & rhs.0)
11615 }
11616}
11617
11618impl std::ops::BitXor for VideoEncodeUsageFlagBitsKHR {
11619 type Output = Self;
11620 fn bitxor(self, rhs: Self) -> Self {
11621 Self(self.0 ^ rhs.0)
11622 }
11623}
11624
11625impl std::ops::Not for VideoEncodeUsageFlagBitsKHR {
11626 type Output = Self;
11627 fn not(self) -> Self {
11628 Self(!self.0)
11629 }
11630}
11631
11632#[repr(transparent)]
11633#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11634pub struct VideoEncodeContentFlagBitsKHR(pub u32);
11635impl VideoEncodeContentFlagBitsKHR {
11636 pub const fn from_raw(value: u32) -> Self {
11637 Self(value)
11638 }
11639
11640 pub const fn as_raw(self) -> u32 {
11641 self.0
11642 }
11643
11644 pub const fn empty() -> Self {
11645 Self(0)
11646 }
11647
11648 pub const DEFAULT_KHR: Self = Self(0);
11649 pub const CAMERA_BIT_KHR: Self = Self(1);
11650 pub const DESKTOP_BIT_KHR: Self = Self(2);
11651 pub const RENDERED_BIT_KHR: Self = Self(4);
11652}
11653
11654impl std::ops::BitOr for VideoEncodeContentFlagBitsKHR {
11655 type Output = Self;
11656 fn bitor(self, rhs: Self) -> Self {
11657 Self(self.0 | rhs.0)
11658 }
11659}
11660
11661impl std::ops::BitAnd for VideoEncodeContentFlagBitsKHR {
11662 type Output = Self;
11663 fn bitand(self, rhs: Self) -> Self {
11664 Self(self.0 & rhs.0)
11665 }
11666}
11667
11668impl std::ops::BitXor for VideoEncodeContentFlagBitsKHR {
11669 type Output = Self;
11670 fn bitxor(self, rhs: Self) -> Self {
11671 Self(self.0 ^ rhs.0)
11672 }
11673}
11674
11675impl std::ops::Not for VideoEncodeContentFlagBitsKHR {
11676 type Output = Self;
11677 fn not(self) -> Self {
11678 Self(!self.0)
11679 }
11680}
11681
11682#[repr(transparent)]
11683#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11684pub struct VideoEncodeTuningModeKHR(pub i32);
11685impl VideoEncodeTuningModeKHR {
11686 pub const fn from_raw(value: i32) -> Self {
11687 Self(value)
11688 }
11689
11690 pub const fn as_raw(self) -> i32 {
11691 self.0
11692 }
11693
11694 pub const fn empty() -> Self {
11695 Self(0)
11696 }
11697
11698 pub const DEFAULT_KHR: Self = Self(0);
11699 pub const HIGH_QUALITY_KHR: Self = Self(1);
11700 pub const LOW_LATENCY_KHR: Self = Self(2);
11701 pub const ULTRA_LOW_LATENCY_KHR: Self = Self(3);
11702 pub const LOSSLESS_KHR: Self = Self(4);
11703}
11704
11705#[repr(transparent)]
11706#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11707pub struct VideoEncodeCapabilityFlagBitsKHR(pub u32);
11708impl VideoEncodeCapabilityFlagBitsKHR {
11709 pub const fn from_raw(value: u32) -> Self {
11710 Self(value)
11711 }
11712
11713 pub const fn as_raw(self) -> u32 {
11714 self.0
11715 }
11716
11717 pub const fn empty() -> Self {
11718 Self(0)
11719 }
11720
11721 pub const PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR: Self = Self(1);
11722 pub const INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR: Self = Self(2);
11723 pub const QUANTIZATION_DELTA_MAP_BIT_KHR: Self = Self(4);
11724 pub const EMPHASIS_MAP_BIT_KHR: Self = Self(8);
11725}
11726
11727impl std::ops::BitOr for VideoEncodeCapabilityFlagBitsKHR {
11728 type Output = Self;
11729 fn bitor(self, rhs: Self) -> Self {
11730 Self(self.0 | rhs.0)
11731 }
11732}
11733
11734impl std::ops::BitAnd for VideoEncodeCapabilityFlagBitsKHR {
11735 type Output = Self;
11736 fn bitand(self, rhs: Self) -> Self {
11737 Self(self.0 & rhs.0)
11738 }
11739}
11740
11741impl std::ops::BitXor for VideoEncodeCapabilityFlagBitsKHR {
11742 type Output = Self;
11743 fn bitxor(self, rhs: Self) -> Self {
11744 Self(self.0 ^ rhs.0)
11745 }
11746}
11747
11748impl std::ops::Not for VideoEncodeCapabilityFlagBitsKHR {
11749 type Output = Self;
11750 fn not(self) -> Self {
11751 Self(!self.0)
11752 }
11753}
11754
11755#[repr(transparent)]
11756#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11757pub struct VideoEncodeFeedbackFlagBitsKHR(pub u32);
11758impl VideoEncodeFeedbackFlagBitsKHR {
11759 pub const fn from_raw(value: u32) -> Self {
11760 Self(value)
11761 }
11762
11763 pub const fn as_raw(self) -> u32 {
11764 self.0
11765 }
11766
11767 pub const fn empty() -> Self {
11768 Self(0)
11769 }
11770
11771 pub const BITSTREAM_BUFFER_OFFSET_BIT_KHR: Self = Self(1);
11772 pub const BITSTREAM_BYTES_WRITTEN_BIT_KHR: Self = Self(2);
11773 pub const BITSTREAM_HAS_OVERRIDES_BIT_KHR: Self = Self(4);
11774 pub const AVERAGE_QUANTIZATION_BIT_KHR: Self = Self(8);
11775 pub const MIN_QUANTIZATION_BIT_KHR: Self = Self(16);
11776 pub const MAX_QUANTIZATION_BIT_KHR: Self = Self(32);
11777 pub const INTRA_PIXELS_BIT_KHR: Self = Self(64);
11778 pub const INTER_PIXELS_BIT_KHR: Self = Self(128);
11779 pub const SKIPPED_PIXELS_BIT_KHR: Self = Self(256);
11780 pub const PICTURE_PARTITION_COUNT_BIT_KHR: Self = Self(512);
11781}
11782
11783impl std::ops::BitOr for VideoEncodeFeedbackFlagBitsKHR {
11784 type Output = Self;
11785 fn bitor(self, rhs: Self) -> Self {
11786 Self(self.0 | rhs.0)
11787 }
11788}
11789
11790impl std::ops::BitAnd for VideoEncodeFeedbackFlagBitsKHR {
11791 type Output = Self;
11792 fn bitand(self, rhs: Self) -> Self {
11793 Self(self.0 & rhs.0)
11794 }
11795}
11796
11797impl std::ops::BitXor for VideoEncodeFeedbackFlagBitsKHR {
11798 type Output = Self;
11799 fn bitxor(self, rhs: Self) -> Self {
11800 Self(self.0 ^ rhs.0)
11801 }
11802}
11803
11804impl std::ops::Not for VideoEncodeFeedbackFlagBitsKHR {
11805 type Output = Self;
11806 fn not(self) -> Self {
11807 Self(!self.0)
11808 }
11809}
11810
11811#[repr(transparent)]
11812#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11813pub struct VideoEncodePerPartitionFeedbackFlagBitsKHR(pub u32);
11814impl VideoEncodePerPartitionFeedbackFlagBitsKHR {
11815 pub const fn from_raw(value: u32) -> Self {
11816 Self(value)
11817 }
11818
11819 pub const fn as_raw(self) -> u32 {
11820 self.0
11821 }
11822
11823 pub const fn empty() -> Self {
11824 Self(0)
11825 }
11826
11827 pub const STATUS_BIT_KHR: Self = Self(1);
11828 pub const BITSTREAM_BUFFER_OFFSET_BIT_KHR: Self = Self(2);
11829 pub const BITSTREAM_BYTES_WRITTEN_BIT_KHR: Self = Self(4);
11830}
11831
11832impl std::ops::BitOr for VideoEncodePerPartitionFeedbackFlagBitsKHR {
11833 type Output = Self;
11834 fn bitor(self, rhs: Self) -> Self {
11835 Self(self.0 | rhs.0)
11836 }
11837}
11838
11839impl std::ops::BitAnd for VideoEncodePerPartitionFeedbackFlagBitsKHR {
11840 type Output = Self;
11841 fn bitand(self, rhs: Self) -> Self {
11842 Self(self.0 & rhs.0)
11843 }
11844}
11845
11846impl std::ops::BitXor for VideoEncodePerPartitionFeedbackFlagBitsKHR {
11847 type Output = Self;
11848 fn bitxor(self, rhs: Self) -> Self {
11849 Self(self.0 ^ rhs.0)
11850 }
11851}
11852
11853impl std::ops::Not for VideoEncodePerPartitionFeedbackFlagBitsKHR {
11854 type Output = Self;
11855 fn not(self) -> Self {
11856 Self(!self.0)
11857 }
11858}
11859
11860#[repr(transparent)]
11861#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11862pub struct VideoEncodeRateControlModeFlagBitsKHR(pub u32);
11863impl VideoEncodeRateControlModeFlagBitsKHR {
11864 pub const fn from_raw(value: u32) -> Self {
11865 Self(value)
11866 }
11867
11868 pub const fn as_raw(self) -> u32 {
11869 self.0
11870 }
11871
11872 pub const fn empty() -> Self {
11873 Self(0)
11874 }
11875
11876 pub const DEFAULT_KHR: Self = Self(0);
11877 pub const DISABLED_BIT_KHR: Self = Self(1);
11878 pub const CBR_BIT_KHR: Self = Self(2);
11879 pub const VBR_BIT_KHR: Self = Self(4);
11880}
11881
11882impl std::ops::BitOr for VideoEncodeRateControlModeFlagBitsKHR {
11883 type Output = Self;
11884 fn bitor(self, rhs: Self) -> Self {
11885 Self(self.0 | rhs.0)
11886 }
11887}
11888
11889impl std::ops::BitAnd for VideoEncodeRateControlModeFlagBitsKHR {
11890 type Output = Self;
11891 fn bitand(self, rhs: Self) -> Self {
11892 Self(self.0 & rhs.0)
11893 }
11894}
11895
11896impl std::ops::BitXor for VideoEncodeRateControlModeFlagBitsKHR {
11897 type Output = Self;
11898 fn bitxor(self, rhs: Self) -> Self {
11899 Self(self.0 ^ rhs.0)
11900 }
11901}
11902
11903impl std::ops::Not for VideoEncodeRateControlModeFlagBitsKHR {
11904 type Output = Self;
11905 fn not(self) -> Self {
11906 Self(!self.0)
11907 }
11908}
11909
11910#[repr(transparent)]
11911#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11912pub struct VideoEncodeIntraRefreshModeFlagBitsKHR(pub u32);
11913impl VideoEncodeIntraRefreshModeFlagBitsKHR {
11914 pub const fn from_raw(value: u32) -> Self {
11915 Self(value)
11916 }
11917
11918 pub const fn as_raw(self) -> u32 {
11919 self.0
11920 }
11921
11922 pub const fn empty() -> Self {
11923 Self(0)
11924 }
11925
11926 pub const NONE_KHR: Self = Self(0);
11927 pub const PER_PICTURE_PARTITION_BIT_KHR: Self = Self(1);
11928 pub const BLOCK_BASED_BIT_KHR: Self = Self(2);
11929 pub const BLOCK_ROW_BASED_BIT_KHR: Self = Self(4);
11930 pub const BLOCK_COLUMN_BASED_BIT_KHR: Self = Self(8);
11931}
11932
11933impl std::ops::BitOr for VideoEncodeIntraRefreshModeFlagBitsKHR {
11934 type Output = Self;
11935 fn bitor(self, rhs: Self) -> Self {
11936 Self(self.0 | rhs.0)
11937 }
11938}
11939
11940impl std::ops::BitAnd for VideoEncodeIntraRefreshModeFlagBitsKHR {
11941 type Output = Self;
11942 fn bitand(self, rhs: Self) -> Self {
11943 Self(self.0 & rhs.0)
11944 }
11945}
11946
11947impl std::ops::BitXor for VideoEncodeIntraRefreshModeFlagBitsKHR {
11948 type Output = Self;
11949 fn bitxor(self, rhs: Self) -> Self {
11950 Self(self.0 ^ rhs.0)
11951 }
11952}
11953
11954impl std::ops::Not for VideoEncodeIntraRefreshModeFlagBitsKHR {
11955 type Output = Self;
11956 fn not(self) -> Self {
11957 Self(!self.0)
11958 }
11959}
11960
11961#[repr(transparent)]
11962#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
11963pub struct VideoEncodeH264CapabilityFlagBitsKHR(pub u32);
11964impl VideoEncodeH264CapabilityFlagBitsKHR {
11965 pub const fn from_raw(value: u32) -> Self {
11966 Self(value)
11967 }
11968
11969 pub const fn as_raw(self) -> u32 {
11970 self.0
11971 }
11972
11973 pub const fn empty() -> Self {
11974 Self(0)
11975 }
11976
11977 pub const HRD_COMPLIANCE_BIT_KHR: Self = Self(1);
11978 pub const PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: Self = Self(2);
11979 pub const ROW_UNALIGNED_SLICE_BIT_KHR: Self = Self(4);
11980 pub const DIFFERENT_SLICE_TYPE_BIT_KHR: Self = Self(8);
11981 pub const B_FRAME_IN_L0_LIST_BIT_KHR: Self = Self(16);
11982 pub const B_FRAME_IN_L1_LIST_BIT_KHR: Self = Self(32);
11983 pub const PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: Self = Self(64);
11984 pub const PER_SLICE_CONSTANT_QP_BIT_KHR: Self = Self(128);
11985 pub const GENERATE_PREFIX_NALU_BIT_KHR: Self = Self(256);
11986 pub const B_PICTURE_INTRA_REFRESH_BIT_KHR: Self = Self(1024);
11987 pub const MB_QP_DIFF_WRAPAROUND_BIT_KHR: Self = Self(512);
11988}
11989
11990impl std::ops::BitOr for VideoEncodeH264CapabilityFlagBitsKHR {
11991 type Output = Self;
11992 fn bitor(self, rhs: Self) -> Self {
11993 Self(self.0 | rhs.0)
11994 }
11995}
11996
11997impl std::ops::BitAnd for VideoEncodeH264CapabilityFlagBitsKHR {
11998 type Output = Self;
11999 fn bitand(self, rhs: Self) -> Self {
12000 Self(self.0 & rhs.0)
12001 }
12002}
12003
12004impl std::ops::BitXor for VideoEncodeH264CapabilityFlagBitsKHR {
12005 type Output = Self;
12006 fn bitxor(self, rhs: Self) -> Self {
12007 Self(self.0 ^ rhs.0)
12008 }
12009}
12010
12011impl std::ops::Not for VideoEncodeH264CapabilityFlagBitsKHR {
12012 type Output = Self;
12013 fn not(self) -> Self {
12014 Self(!self.0)
12015 }
12016}
12017
12018#[repr(transparent)]
12019#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12020pub struct VideoEncodeH264StdFlagBitsKHR(pub u32);
12021impl VideoEncodeH264StdFlagBitsKHR {
12022 pub const fn from_raw(value: u32) -> Self {
12023 Self(value)
12024 }
12025
12026 pub const fn as_raw(self) -> u32 {
12027 self.0
12028 }
12029
12030 pub const fn empty() -> Self {
12031 Self(0)
12032 }
12033
12034 pub const SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: Self = Self(1);
12035 pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR: Self = Self(2);
12036 pub const SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR: Self = Self(4);
12037 pub const CHROMA_QP_INDEX_OFFSET_BIT_KHR: Self = Self(8);
12038 pub const SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR: Self = Self(16);
12039 pub const PIC_INIT_QP_MINUS26_BIT_KHR: Self = Self(32);
12040 pub const WEIGHTED_PRED_FLAG_SET_BIT_KHR: Self = Self(64);
12041 pub const WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR: Self = Self(128);
12042 pub const WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR: Self = Self(256);
12043 pub const TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR: Self = Self(512);
12044 pub const DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR: Self = Self(1024);
12045 pub const ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR: Self = Self(2048);
12046 pub const ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR: Self = Self(4096);
12047 pub const DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR: Self = Self(8192);
12048 pub const CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: Self = Self(16384);
12049 pub const DEBLOCKING_FILTER_DISABLED_BIT_KHR: Self = Self(32768);
12050 pub const DEBLOCKING_FILTER_ENABLED_BIT_KHR: Self = Self(65536);
12051 pub const DEBLOCKING_FILTER_PARTIAL_BIT_KHR: Self = Self(131072);
12052 pub const SLICE_QP_DELTA_BIT_KHR: Self = Self(524288);
12053 pub const DIFFERENT_SLICE_QP_DELTA_BIT_KHR: Self = Self(1048576);
12054}
12055
12056impl std::ops::BitOr for VideoEncodeH264StdFlagBitsKHR {
12057 type Output = Self;
12058 fn bitor(self, rhs: Self) -> Self {
12059 Self(self.0 | rhs.0)
12060 }
12061}
12062
12063impl std::ops::BitAnd for VideoEncodeH264StdFlagBitsKHR {
12064 type Output = Self;
12065 fn bitand(self, rhs: Self) -> Self {
12066 Self(self.0 & rhs.0)
12067 }
12068}
12069
12070impl std::ops::BitXor for VideoEncodeH264StdFlagBitsKHR {
12071 type Output = Self;
12072 fn bitxor(self, rhs: Self) -> Self {
12073 Self(self.0 ^ rhs.0)
12074 }
12075}
12076
12077impl std::ops::Not for VideoEncodeH264StdFlagBitsKHR {
12078 type Output = Self;
12079 fn not(self) -> Self {
12080 Self(!self.0)
12081 }
12082}
12083
12084#[repr(transparent)]
12085#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12086pub struct VideoEncodeH264RateControlFlagBitsKHR(pub u32);
12087impl VideoEncodeH264RateControlFlagBitsKHR {
12088 pub const fn from_raw(value: u32) -> Self {
12089 Self(value)
12090 }
12091
12092 pub const fn as_raw(self) -> u32 {
12093 self.0
12094 }
12095
12096 pub const fn empty() -> Self {
12097 Self(0)
12098 }
12099
12100 pub const ATTEMPT_HRD_COMPLIANCE_BIT_KHR: Self = Self(1);
12101 pub const REGULAR_GOP_BIT_KHR: Self = Self(2);
12102 pub const REFERENCE_PATTERN_FLAT_BIT_KHR: Self = Self(4);
12103 pub const REFERENCE_PATTERN_DYADIC_BIT_KHR: Self = Self(8);
12104 pub const TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: Self = Self(16);
12105}
12106
12107impl std::ops::BitOr for VideoEncodeH264RateControlFlagBitsKHR {
12108 type Output = Self;
12109 fn bitor(self, rhs: Self) -> Self {
12110 Self(self.0 | rhs.0)
12111 }
12112}
12113
12114impl std::ops::BitAnd for VideoEncodeH264RateControlFlagBitsKHR {
12115 type Output = Self;
12116 fn bitand(self, rhs: Self) -> Self {
12117 Self(self.0 & rhs.0)
12118 }
12119}
12120
12121impl std::ops::BitXor for VideoEncodeH264RateControlFlagBitsKHR {
12122 type Output = Self;
12123 fn bitxor(self, rhs: Self) -> Self {
12124 Self(self.0 ^ rhs.0)
12125 }
12126}
12127
12128impl std::ops::Not for VideoEncodeH264RateControlFlagBitsKHR {
12129 type Output = Self;
12130 fn not(self) -> Self {
12131 Self(!self.0)
12132 }
12133}
12134
12135#[repr(transparent)]
12136#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12137pub struct HostImageCopyFlagBits(pub u32);
12138impl HostImageCopyFlagBits {
12139 pub const fn from_raw(value: u32) -> Self {
12140 Self(value)
12141 }
12142
12143 pub const fn as_raw(self) -> u32 {
12144 self.0
12145 }
12146
12147 pub const fn empty() -> Self {
12148 Self(0)
12149 }
12150
12151 pub const MEMCPY_BIT: Self = Self(1);
12152 pub const MEMCPY: Self = Self(1);
12153 pub const MEMCPY_BIT_EXT: Self = Self(1);
12154 pub const MEMCPY_EXT: Self = Self(1);
12155}
12156
12157impl std::ops::BitOr for HostImageCopyFlagBits {
12158 type Output = Self;
12159 fn bitor(self, rhs: Self) -> Self {
12160 Self(self.0 | rhs.0)
12161 }
12162}
12163
12164impl std::ops::BitAnd for HostImageCopyFlagBits {
12165 type Output = Self;
12166 fn bitand(self, rhs: Self) -> Self {
12167 Self(self.0 & rhs.0)
12168 }
12169}
12170
12171impl std::ops::BitXor for HostImageCopyFlagBits {
12172 type Output = Self;
12173 fn bitxor(self, rhs: Self) -> Self {
12174 Self(self.0 ^ rhs.0)
12175 }
12176}
12177
12178impl std::ops::Not for HostImageCopyFlagBits {
12179 type Output = Self;
12180 fn not(self) -> Self {
12181 Self(!self.0)
12182 }
12183}
12184
12185#[repr(transparent)]
12186#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12187pub struct PartitionedAccelerationStructureOpTypeNV(pub i32);
12188impl PartitionedAccelerationStructureOpTypeNV {
12189 pub const fn from_raw(value: i32) -> Self {
12190 Self(value)
12191 }
12192
12193 pub const fn as_raw(self) -> i32 {
12194 self.0
12195 }
12196
12197 pub const fn empty() -> Self {
12198 Self(0)
12199 }
12200
12201 pub const WRITE_INSTANCE_NV: Self = Self(0);
12202 pub const UPDATE_INSTANCE_NV: Self = Self(1);
12203 pub const WRITE_PARTITION_TRANSLATION_NV: Self = Self(2);
12204}
12205
12206#[repr(transparent)]
12207#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12208pub struct PartitionedAccelerationStructureInstanceFlagBitsNV(pub u32);
12209impl PartitionedAccelerationStructureInstanceFlagBitsNV {
12210 pub const fn from_raw(value: u32) -> Self {
12211 Self(value)
12212 }
12213
12214 pub const fn as_raw(self) -> u32 {
12215 self.0
12216 }
12217
12218 pub const fn empty() -> Self {
12219 Self(0)
12220 }
12221
12222 pub const FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV: Self = Self(1);
12223 pub const FLAG_TRIANGLE_FLIP_FACING_BIT_NV: Self = Self(2);
12224 pub const FLAG_FORCE_OPAQUE_BIT_NV: Self = Self(4);
12225 pub const FLAG_FORCE_NO_OPAQUE_BIT_NV: Self = Self(8);
12226 pub const FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV: Self = Self(16);
12227}
12228
12229impl std::ops::BitOr for PartitionedAccelerationStructureInstanceFlagBitsNV {
12230 type Output = Self;
12231 fn bitor(self, rhs: Self) -> Self {
12232 Self(self.0 | rhs.0)
12233 }
12234}
12235
12236impl std::ops::BitAnd for PartitionedAccelerationStructureInstanceFlagBitsNV {
12237 type Output = Self;
12238 fn bitand(self, rhs: Self) -> Self {
12239 Self(self.0 & rhs.0)
12240 }
12241}
12242
12243impl std::ops::BitXor for PartitionedAccelerationStructureInstanceFlagBitsNV {
12244 type Output = Self;
12245 fn bitxor(self, rhs: Self) -> Self {
12246 Self(self.0 ^ rhs.0)
12247 }
12248}
12249
12250impl std::ops::Not for PartitionedAccelerationStructureInstanceFlagBitsNV {
12251 type Output = Self;
12252 fn not(self) -> Self {
12253 Self(!self.0)
12254 }
12255}
12256
12257#[cfg(feature = "platform-fuchsia")]
12258#[repr(transparent)]
12259#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12260pub struct ImageConstraintsInfoFlagBitsFUCHSIA(pub u32);
12261#[cfg(feature = "platform-fuchsia")]
12262impl ImageConstraintsInfoFlagBitsFUCHSIA {
12263 pub const fn from_raw(value: u32) -> Self {
12264 Self(value)
12265 }
12266
12267 pub const fn as_raw(self) -> u32 {
12268 self.0
12269 }
12270
12271 pub const fn empty() -> Self {
12272 Self(0)
12273 }
12274
12275 pub const CPU_READ_RARELY_FUCHSIA: Self = Self(1);
12276 pub const CPU_READ_OFTEN_FUCHSIA: Self = Self(2);
12277 pub const CPU_WRITE_RARELY_FUCHSIA: Self = Self(4);
12278 pub const CPU_WRITE_OFTEN_FUCHSIA: Self = Self(8);
12279 pub const PROTECTED_OPTIONAL_FUCHSIA: Self = Self(16);
12280}
12281
12282#[cfg(feature = "platform-fuchsia")]
12283impl std::ops::BitOr for ImageConstraintsInfoFlagBitsFUCHSIA {
12284 type Output = Self;
12285 fn bitor(self, rhs: Self) -> Self {
12286 Self(self.0 | rhs.0)
12287 }
12288}
12289
12290#[cfg(feature = "platform-fuchsia")]
12291impl std::ops::BitAnd for ImageConstraintsInfoFlagBitsFUCHSIA {
12292 type Output = Self;
12293 fn bitand(self, rhs: Self) -> Self {
12294 Self(self.0 & rhs.0)
12295 }
12296}
12297
12298#[cfg(feature = "platform-fuchsia")]
12299impl std::ops::BitXor for ImageConstraintsInfoFlagBitsFUCHSIA {
12300 type Output = Self;
12301 fn bitxor(self, rhs: Self) -> Self {
12302 Self(self.0 ^ rhs.0)
12303 }
12304}
12305
12306#[cfg(feature = "platform-fuchsia")]
12307impl std::ops::Not for ImageConstraintsInfoFlagBitsFUCHSIA {
12308 type Output = Self;
12309 fn not(self) -> Self {
12310 Self(!self.0)
12311 }
12312}
12313
12314#[repr(transparent)]
12315#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12316pub struct FormatFeatureFlagBits2(pub u64);
12317impl FormatFeatureFlagBits2 {
12318 pub const fn from_raw(value: u64) -> Self {
12319 Self(value)
12320 }
12321
12322 pub const fn as_raw(self) -> u64 {
12323 self.0
12324 }
12325
12326 pub const fn empty() -> Self {
12327 Self(0)
12328 }
12329
12330 pub const SAMPLED_IMAGE_BIT: Self = Self(1);
12331 pub const STORAGE_IMAGE_BIT: Self = Self(2);
12332 pub const STORAGE_IMAGE_ATOMIC_BIT: Self = Self(4);
12333 pub const UNIFORM_TEXEL_BUFFER_BIT: Self = Self(8);
12334 pub const STORAGE_TEXEL_BUFFER_BIT: Self = Self(16);
12335 pub const STORAGE_TEXEL_BUFFER_ATOMIC_BIT: Self = Self(32);
12336 pub const VERTEX_BUFFER_BIT: Self = Self(64);
12337 pub const COLOR_ATTACHMENT_BIT: Self = Self(128);
12338 pub const COLOR_ATTACHMENT_BLEND_BIT: Self = Self(256);
12339 pub const DEPTH_STENCIL_ATTACHMENT_BIT: Self = Self(512);
12340 pub const BLIT_SRC_BIT: Self = Self(1024);
12341 pub const BLIT_DST_BIT: Self = Self(2048);
12342 pub const SAMPLED_IMAGE_FILTER_LINEAR_BIT: Self = Self(4096);
12343 pub const TRANSFER_SRC_BIT: Self = Self(16384);
12344 pub const TRANSFER_DST_BIT: Self = Self(32768);
12345 pub const SAMPLED_IMAGE_FILTER_MINMAX_BIT: Self = Self(65536);
12346 pub const MIDPOINT_CHROMA_SAMPLES_BIT: Self = Self(131072);
12347 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: Self = Self(262144);
12348 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: Self = Self(524288);
12349 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: Self = Self(1048576);
12350 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: Self =
12351 Self(2097152);
12352 pub const DISJOINT_BIT: Self = Self(4194304);
12353 pub const COSITED_CHROMA_SAMPLES_BIT: Self = Self(8388608);
12354 pub const STORAGE_READ_WITHOUT_FORMAT_BIT: Self = Self(2147483648);
12355 pub const STORAGE_WRITE_WITHOUT_FORMAT_BIT: Self = Self(4294967296);
12356 pub const SAMPLED_IMAGE_DEPTH_COMPARISON_BIT: Self = Self(8589934592);
12357 pub const SAMPLED_IMAGE_FILTER_CUBIC_BIT: Self = Self(8192);
12358 pub const HOST_IMAGE_TRANSFER_BIT: Self = Self(70368744177664);
12359 pub const VIDEO_DECODE_OUTPUT_BIT_KHR: Self = Self(33554432);
12360 pub const VIDEO_DECODE_DPB_BIT_KHR: Self = Self(67108864);
12361 pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: Self = Self(536870912);
12362 pub const FRAGMENT_DENSITY_MAP_BIT_EXT: Self = Self(16777216);
12363 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: Self = Self(1073741824);
12364 pub const HOST_IMAGE_TRANSFER_BIT_EXT: Self = Self(70368744177664);
12365 pub const VIDEO_ENCODE_INPUT_BIT_KHR: Self = Self(134217728);
12366 pub const VIDEO_ENCODE_DPB_BIT_KHR: Self = Self(268435456);
12367 pub const BLOCK_MATCHING_SXD_BIT_QCOM: Self = Self(17592186044416);
12368 pub const SAMPLED_IMAGE_BIT_KHR: Self = Self(1);
12369 pub const STORAGE_IMAGE_BIT_KHR: Self = Self(2);
12370 pub const STORAGE_IMAGE_ATOMIC_BIT_KHR: Self = Self(4);
12371 pub const UNIFORM_TEXEL_BUFFER_BIT_KHR: Self = Self(8);
12372 pub const STORAGE_TEXEL_BUFFER_BIT_KHR: Self = Self(16);
12373 pub const STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR: Self = Self(32);
12374 pub const VERTEX_BUFFER_BIT_KHR: Self = Self(64);
12375 pub const COLOR_ATTACHMENT_BIT_KHR: Self = Self(128);
12376 pub const COLOR_ATTACHMENT_BLEND_BIT_KHR: Self = Self(256);
12377 pub const DEPTH_STENCIL_ATTACHMENT_BIT_KHR: Self = Self(512);
12378 pub const BLIT_SRC_BIT_KHR: Self = Self(1024);
12379 pub const BLIT_DST_BIT_KHR: Self = Self(2048);
12380 pub const SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR: Self = Self(4096);
12381 pub const TRANSFER_SRC_BIT_KHR: Self = Self(16384);
12382 pub const TRANSFER_DST_BIT_KHR: Self = Self(32768);
12383 pub const MIDPOINT_CHROMA_SAMPLES_BIT_KHR: Self = Self(131072);
12384 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: Self = Self(262144);
12385 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: Self =
12386 Self(524288);
12387 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: Self =
12388 Self(1048576);
12389 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: Self =
12390 Self(2097152);
12391 pub const DISJOINT_BIT_KHR: Self = Self(4194304);
12392 pub const COSITED_CHROMA_SAMPLES_BIT_KHR: Self = Self(8388608);
12393 pub const STORAGE_READ_WITHOUT_FORMAT_BIT_KHR: Self = Self(2147483648);
12394 pub const STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR: Self = Self(4294967296);
12395 pub const SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR: Self = Self(8589934592);
12396 pub const SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR: Self = Self(65536);
12397 pub const SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: Self = Self(8192);
12398 pub const ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV: Self = Self(2251799813685248);
12399 pub const LINEAR_COLOR_ATTACHMENT_BIT_NV: Self = Self(274877906944);
12400 pub const WEIGHT_IMAGE_BIT_QCOM: Self = Self(17179869184);
12401 pub const WEIGHT_SAMPLED_IMAGE_BIT_QCOM: Self = Self(34359738368);
12402 pub const BLOCK_MATCHING_BIT_QCOM: Self = Self(68719476736);
12403 pub const BOX_FILTER_SAMPLED_BIT_QCOM: Self = Self(137438953472);
12404 pub const TENSOR_SHADER_BIT_ARM: Self = Self(549755813888);
12405 pub const TENSOR_IMAGE_ALIASING_BIT_ARM: Self = Self(8796093022208);
12406 pub const OPTICAL_FLOW_IMAGE_BIT_NV: Self = Self(1099511627776);
12407 pub const OPTICAL_FLOW_VECTOR_BIT_NV: Self = Self(2199023255552);
12408 pub const OPTICAL_FLOW_COST_BIT_NV: Self = Self(4398046511104);
12409 pub const TENSOR_DATA_GRAPH_BIT_ARM: Self = Self(281474976710656);
12410 pub const COPY_IMAGE_INDIRECT_DST_BIT_KHR: Self = Self(576460752303423488);
12411 pub const VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: Self = Self(562949953421312);
12412 pub const VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: Self = Self(1125899906842624);
12413 pub const SAMPLED_IMAGE_FILTER_LINEAR_2D_BIT_IMG: Self = Self(35184372088832);
12414 pub const DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR: Self = Self(4503599627370496);
12415 pub const DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR: Self = Self(9007199254740992);
12416 pub const STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR: Self = Self(18014398509481984);
12417 pub const STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR: Self = Self(36028797018963968);
12418 pub const DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM: Self = Self(72057594037927936);
12419 pub const DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM: Self = Self(144115188075855872);
12420 pub const DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM: Self = Self(288230376151711744);
12421}
12422
12423impl std::ops::BitOr for FormatFeatureFlagBits2 {
12424 type Output = Self;
12425 fn bitor(self, rhs: Self) -> Self {
12426 Self(self.0 | rhs.0)
12427 }
12428}
12429
12430impl std::ops::BitAnd for FormatFeatureFlagBits2 {
12431 type Output = Self;
12432 fn bitand(self, rhs: Self) -> Self {
12433 Self(self.0 & rhs.0)
12434 }
12435}
12436
12437impl std::ops::BitXor for FormatFeatureFlagBits2 {
12438 type Output = Self;
12439 fn bitxor(self, rhs: Self) -> Self {
12440 Self(self.0 ^ rhs.0)
12441 }
12442}
12443
12444impl std::ops::Not for FormatFeatureFlagBits2 {
12445 type Output = Self;
12446 fn not(self) -> Self {
12447 Self(!self.0)
12448 }
12449}
12450
12451#[repr(transparent)]
12452#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12453pub struct FormatFeatureFlagBits4KHR(pub u64);
12454impl FormatFeatureFlagBits4KHR {
12455 pub const fn from_raw(value: u64) -> Self {
12456 Self(value)
12457 }
12458
12459 pub const fn as_raw(self) -> u64 {
12460 self.0
12461 }
12462
12463 pub const fn empty() -> Self {
12464 Self(0)
12465 }
12466}
12467
12468impl std::ops::BitOr for FormatFeatureFlagBits4KHR {
12469 type Output = Self;
12470 fn bitor(self, rhs: Self) -> Self {
12471 Self(self.0 | rhs.0)
12472 }
12473}
12474
12475impl std::ops::BitAnd for FormatFeatureFlagBits4KHR {
12476 type Output = Self;
12477 fn bitand(self, rhs: Self) -> Self {
12478 Self(self.0 & rhs.0)
12479 }
12480}
12481
12482impl std::ops::BitXor for FormatFeatureFlagBits4KHR {
12483 type Output = Self;
12484 fn bitxor(self, rhs: Self) -> Self {
12485 Self(self.0 ^ rhs.0)
12486 }
12487}
12488
12489impl std::ops::Not for FormatFeatureFlagBits4KHR {
12490 type Output = Self;
12491 fn not(self) -> Self {
12492 Self(!self.0)
12493 }
12494}
12495
12496#[repr(transparent)]
12497#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12498pub struct RenderingFlagBits(pub u32);
12499impl RenderingFlagBits {
12500 pub const fn from_raw(value: u32) -> Self {
12501 Self(value)
12502 }
12503
12504 pub const fn as_raw(self) -> u32 {
12505 self.0
12506 }
12507
12508 pub const fn empty() -> Self {
12509 Self(0)
12510 }
12511
12512 pub const CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT: Self = Self(1);
12513 pub const SUSPENDING_BIT: Self = Self(2);
12514 pub const RESUMING_BIT: Self = Self(4);
12515 pub const CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR: Self = Self(1);
12516 pub const SUSPENDING_BIT_KHR: Self = Self(2);
12517 pub const RESUMING_BIT_KHR: Self = Self(4);
12518 pub const CONTENTS_INLINE_BIT_EXT: Self = Self(16);
12519 pub const ENABLE_LEGACY_DITHERING_BIT_EXT: Self = Self(8);
12520 pub const CONTENTS_INLINE_BIT_KHR: Self = Self(16);
12521 pub const PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: Self = Self(32);
12522 pub const FRAGMENT_REGION_BIT_EXT: Self = Self(64);
12523 pub const CUSTOM_RESOLVE_BIT_EXT: Self = Self(128);
12524 pub const LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR: Self = Self(256);
12525}
12526
12527impl std::ops::BitOr for RenderingFlagBits {
12528 type Output = Self;
12529 fn bitor(self, rhs: Self) -> Self {
12530 Self(self.0 | rhs.0)
12531 }
12532}
12533
12534impl std::ops::BitAnd for RenderingFlagBits {
12535 type Output = Self;
12536 fn bitand(self, rhs: Self) -> Self {
12537 Self(self.0 & rhs.0)
12538 }
12539}
12540
12541impl std::ops::BitXor for RenderingFlagBits {
12542 type Output = Self;
12543 fn bitxor(self, rhs: Self) -> Self {
12544 Self(self.0 ^ rhs.0)
12545 }
12546}
12547
12548impl std::ops::Not for RenderingFlagBits {
12549 type Output = Self;
12550 fn not(self) -> Self {
12551 Self(!self.0)
12552 }
12553}
12554
12555#[repr(transparent)]
12556#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12557pub struct VideoEncodeH265CapabilityFlagBitsKHR(pub u32);
12558impl VideoEncodeH265CapabilityFlagBitsKHR {
12559 pub const fn from_raw(value: u32) -> Self {
12560 Self(value)
12561 }
12562
12563 pub const fn as_raw(self) -> u32 {
12564 self.0
12565 }
12566
12567 pub const fn empty() -> Self {
12568 Self(0)
12569 }
12570
12571 pub const HRD_COMPLIANCE_BIT_KHR: Self = Self(1);
12572 pub const PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: Self = Self(2);
12573 pub const ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR: Self = Self(4);
12574 pub const DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR: Self = Self(8);
12575 pub const B_FRAME_IN_L0_LIST_BIT_KHR: Self = Self(16);
12576 pub const B_FRAME_IN_L1_LIST_BIT_KHR: Self = Self(32);
12577 pub const PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: Self = Self(64);
12578 pub const PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR: Self = Self(128);
12579 pub const MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR: Self = Self(256);
12580 pub const MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR: Self = Self(512);
12581 pub const B_PICTURE_INTRA_REFRESH_BIT_KHR: Self = Self(2048);
12582 pub const CU_QP_DIFF_WRAPAROUND_BIT_KHR: Self = Self(1024);
12583}
12584
12585impl std::ops::BitOr for VideoEncodeH265CapabilityFlagBitsKHR {
12586 type Output = Self;
12587 fn bitor(self, rhs: Self) -> Self {
12588 Self(self.0 | rhs.0)
12589 }
12590}
12591
12592impl std::ops::BitAnd for VideoEncodeH265CapabilityFlagBitsKHR {
12593 type Output = Self;
12594 fn bitand(self, rhs: Self) -> Self {
12595 Self(self.0 & rhs.0)
12596 }
12597}
12598
12599impl std::ops::BitXor for VideoEncodeH265CapabilityFlagBitsKHR {
12600 type Output = Self;
12601 fn bitxor(self, rhs: Self) -> Self {
12602 Self(self.0 ^ rhs.0)
12603 }
12604}
12605
12606impl std::ops::Not for VideoEncodeH265CapabilityFlagBitsKHR {
12607 type Output = Self;
12608 fn not(self) -> Self {
12609 Self(!self.0)
12610 }
12611}
12612
12613#[repr(transparent)]
12614#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12615pub struct VideoEncodeH265StdFlagBitsKHR(pub u32);
12616impl VideoEncodeH265StdFlagBitsKHR {
12617 pub const fn from_raw(value: u32) -> Self {
12618 Self(value)
12619 }
12620
12621 pub const fn as_raw(self) -> u32 {
12622 self.0
12623 }
12624
12625 pub const fn empty() -> Self {
12626 Self(0)
12627 }
12628
12629 pub const SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: Self = Self(1);
12630 pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR: Self = Self(2);
12631 pub const SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR: Self = Self(4);
12632 pub const PCM_ENABLED_FLAG_SET_BIT_KHR: Self = Self(8);
12633 pub const SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR: Self = Self(16);
12634 pub const INIT_QP_MINUS26_BIT_KHR: Self = Self(32);
12635 pub const WEIGHTED_PRED_FLAG_SET_BIT_KHR: Self = Self(64);
12636 pub const WEIGHTED_BIPRED_FLAG_SET_BIT_KHR: Self = Self(128);
12637 pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR: Self = Self(256);
12638 pub const SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR: Self = Self(512);
12639 pub const TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR: Self = Self(1024);
12640 pub const TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR: Self = Self(2048);
12641 pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR: Self = Self(4096);
12642 pub const TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR: Self = Self(8192);
12643 pub const CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: Self = Self(16384);
12644 pub const ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR: Self = Self(32768);
12645 pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR: Self = Self(65536);
12646 pub const DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR: Self = Self(131072);
12647 pub const DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR: Self = Self(262144);
12648 pub const SLICE_QP_DELTA_BIT_KHR: Self = Self(524288);
12649 pub const DIFFERENT_SLICE_QP_DELTA_BIT_KHR: Self = Self(1048576);
12650}
12651
12652impl std::ops::BitOr for VideoEncodeH265StdFlagBitsKHR {
12653 type Output = Self;
12654 fn bitor(self, rhs: Self) -> Self {
12655 Self(self.0 | rhs.0)
12656 }
12657}
12658
12659impl std::ops::BitAnd for VideoEncodeH265StdFlagBitsKHR {
12660 type Output = Self;
12661 fn bitand(self, rhs: Self) -> Self {
12662 Self(self.0 & rhs.0)
12663 }
12664}
12665
12666impl std::ops::BitXor for VideoEncodeH265StdFlagBitsKHR {
12667 type Output = Self;
12668 fn bitxor(self, rhs: Self) -> Self {
12669 Self(self.0 ^ rhs.0)
12670 }
12671}
12672
12673impl std::ops::Not for VideoEncodeH265StdFlagBitsKHR {
12674 type Output = Self;
12675 fn not(self) -> Self {
12676 Self(!self.0)
12677 }
12678}
12679
12680#[repr(transparent)]
12681#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12682pub struct VideoEncodeH265RateControlFlagBitsKHR(pub u32);
12683impl VideoEncodeH265RateControlFlagBitsKHR {
12684 pub const fn from_raw(value: u32) -> Self {
12685 Self(value)
12686 }
12687
12688 pub const fn as_raw(self) -> u32 {
12689 self.0
12690 }
12691
12692 pub const fn empty() -> Self {
12693 Self(0)
12694 }
12695
12696 pub const ATTEMPT_HRD_COMPLIANCE_BIT_KHR: Self = Self(1);
12697 pub const REGULAR_GOP_BIT_KHR: Self = Self(2);
12698 pub const REFERENCE_PATTERN_FLAT_BIT_KHR: Self = Self(4);
12699 pub const REFERENCE_PATTERN_DYADIC_BIT_KHR: Self = Self(8);
12700 pub const TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR: Self = Self(16);
12701}
12702
12703impl std::ops::BitOr for VideoEncodeH265RateControlFlagBitsKHR {
12704 type Output = Self;
12705 fn bitor(self, rhs: Self) -> Self {
12706 Self(self.0 | rhs.0)
12707 }
12708}
12709
12710impl std::ops::BitAnd for VideoEncodeH265RateControlFlagBitsKHR {
12711 type Output = Self;
12712 fn bitand(self, rhs: Self) -> Self {
12713 Self(self.0 & rhs.0)
12714 }
12715}
12716
12717impl std::ops::BitXor for VideoEncodeH265RateControlFlagBitsKHR {
12718 type Output = Self;
12719 fn bitxor(self, rhs: Self) -> Self {
12720 Self(self.0 ^ rhs.0)
12721 }
12722}
12723
12724impl std::ops::Not for VideoEncodeH265RateControlFlagBitsKHR {
12725 type Output = Self;
12726 fn not(self) -> Self {
12727 Self(!self.0)
12728 }
12729}
12730
12731#[repr(transparent)]
12732#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12733pub struct VideoEncodeH265CtbSizeFlagBitsKHR(pub u32);
12734impl VideoEncodeH265CtbSizeFlagBitsKHR {
12735 pub const fn from_raw(value: u32) -> Self {
12736 Self(value)
12737 }
12738
12739 pub const fn as_raw(self) -> u32 {
12740 self.0
12741 }
12742
12743 pub const fn empty() -> Self {
12744 Self(0)
12745 }
12746
12747 pub const _16_BIT_KHR: Self = Self(1);
12748 pub const _32_BIT_KHR: Self = Self(2);
12749 pub const _64_BIT_KHR: Self = Self(4);
12750}
12751
12752impl std::ops::BitOr for VideoEncodeH265CtbSizeFlagBitsKHR {
12753 type Output = Self;
12754 fn bitor(self, rhs: Self) -> Self {
12755 Self(self.0 | rhs.0)
12756 }
12757}
12758
12759impl std::ops::BitAnd for VideoEncodeH265CtbSizeFlagBitsKHR {
12760 type Output = Self;
12761 fn bitand(self, rhs: Self) -> Self {
12762 Self(self.0 & rhs.0)
12763 }
12764}
12765
12766impl std::ops::BitXor for VideoEncodeH265CtbSizeFlagBitsKHR {
12767 type Output = Self;
12768 fn bitxor(self, rhs: Self) -> Self {
12769 Self(self.0 ^ rhs.0)
12770 }
12771}
12772
12773impl std::ops::Not for VideoEncodeH265CtbSizeFlagBitsKHR {
12774 type Output = Self;
12775 fn not(self) -> Self {
12776 Self(!self.0)
12777 }
12778}
12779
12780#[repr(transparent)]
12781#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12782pub struct VideoEncodeH265TransformBlockSizeFlagBitsKHR(pub u32);
12783impl VideoEncodeH265TransformBlockSizeFlagBitsKHR {
12784 pub const fn from_raw(value: u32) -> Self {
12785 Self(value)
12786 }
12787
12788 pub const fn as_raw(self) -> u32 {
12789 self.0
12790 }
12791
12792 pub const fn empty() -> Self {
12793 Self(0)
12794 }
12795
12796 pub const _4_BIT_KHR: Self = Self(1);
12797 pub const _8_BIT_KHR: Self = Self(2);
12798 pub const _16_BIT_KHR: Self = Self(4);
12799 pub const _32_BIT_KHR: Self = Self(8);
12800}
12801
12802impl std::ops::BitOr for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
12803 type Output = Self;
12804 fn bitor(self, rhs: Self) -> Self {
12805 Self(self.0 | rhs.0)
12806 }
12807}
12808
12809impl std::ops::BitAnd for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
12810 type Output = Self;
12811 fn bitand(self, rhs: Self) -> Self {
12812 Self(self.0 & rhs.0)
12813 }
12814}
12815
12816impl std::ops::BitXor for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
12817 type Output = Self;
12818 fn bitxor(self, rhs: Self) -> Self {
12819 Self(self.0 ^ rhs.0)
12820 }
12821}
12822
12823impl std::ops::Not for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
12824 type Output = Self;
12825 fn not(self) -> Self {
12826 Self(!self.0)
12827 }
12828}
12829
12830#[repr(transparent)]
12831#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12832pub struct VideoEncodeAV1CapabilityFlagBitsKHR(pub u32);
12833impl VideoEncodeAV1CapabilityFlagBitsKHR {
12834 pub const fn from_raw(value: u32) -> Self {
12835 Self(value)
12836 }
12837
12838 pub const fn as_raw(self) -> u32 {
12839 self.0
12840 }
12841
12842 pub const fn empty() -> Self {
12843 Self(0)
12844 }
12845
12846 pub const PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR: Self = Self(1);
12847 pub const GENERATE_OBU_EXTENSION_HEADER_BIT_KHR: Self = Self(2);
12848 pub const PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR: Self = Self(4);
12849 pub const FRAME_SIZE_OVERRIDE_BIT_KHR: Self = Self(8);
12850 pub const MOTION_VECTOR_SCALING_BIT_KHR: Self = Self(16);
12851 pub const COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR: Self = Self(32);
12852}
12853
12854impl std::ops::BitOr for VideoEncodeAV1CapabilityFlagBitsKHR {
12855 type Output = Self;
12856 fn bitor(self, rhs: Self) -> Self {
12857 Self(self.0 | rhs.0)
12858 }
12859}
12860
12861impl std::ops::BitAnd for VideoEncodeAV1CapabilityFlagBitsKHR {
12862 type Output = Self;
12863 fn bitand(self, rhs: Self) -> Self {
12864 Self(self.0 & rhs.0)
12865 }
12866}
12867
12868impl std::ops::BitXor for VideoEncodeAV1CapabilityFlagBitsKHR {
12869 type Output = Self;
12870 fn bitxor(self, rhs: Self) -> Self {
12871 Self(self.0 ^ rhs.0)
12872 }
12873}
12874
12875impl std::ops::Not for VideoEncodeAV1CapabilityFlagBitsKHR {
12876 type Output = Self;
12877 fn not(self) -> Self {
12878 Self(!self.0)
12879 }
12880}
12881
12882#[repr(transparent)]
12883#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12884pub struct VideoEncodeAV1StdFlagBitsKHR(pub u32);
12885impl VideoEncodeAV1StdFlagBitsKHR {
12886 pub const fn from_raw(value: u32) -> Self {
12887 Self(value)
12888 }
12889
12890 pub const fn as_raw(self) -> u32 {
12891 self.0
12892 }
12893
12894 pub const fn empty() -> Self {
12895 Self(0)
12896 }
12897
12898 pub const UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR: Self = Self(1);
12899 pub const SKIP_MODE_PRESENT_UNSET_BIT_KHR: Self = Self(2);
12900 pub const PRIMARY_REF_FRAME_BIT_KHR: Self = Self(4);
12901 pub const DELTA_Q_BIT_KHR: Self = Self(8);
12902}
12903
12904impl std::ops::BitOr for VideoEncodeAV1StdFlagBitsKHR {
12905 type Output = Self;
12906 fn bitor(self, rhs: Self) -> Self {
12907 Self(self.0 | rhs.0)
12908 }
12909}
12910
12911impl std::ops::BitAnd for VideoEncodeAV1StdFlagBitsKHR {
12912 type Output = Self;
12913 fn bitand(self, rhs: Self) -> Self {
12914 Self(self.0 & rhs.0)
12915 }
12916}
12917
12918impl std::ops::BitXor for VideoEncodeAV1StdFlagBitsKHR {
12919 type Output = Self;
12920 fn bitxor(self, rhs: Self) -> Self {
12921 Self(self.0 ^ rhs.0)
12922 }
12923}
12924
12925impl std::ops::Not for VideoEncodeAV1StdFlagBitsKHR {
12926 type Output = Self;
12927 fn not(self) -> Self {
12928 Self(!self.0)
12929 }
12930}
12931
12932#[repr(transparent)]
12933#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12934pub struct VideoEncodeAV1RateControlFlagBitsKHR(pub u32);
12935impl VideoEncodeAV1RateControlFlagBitsKHR {
12936 pub const fn from_raw(value: u32) -> Self {
12937 Self(value)
12938 }
12939
12940 pub const fn as_raw(self) -> u32 {
12941 self.0
12942 }
12943
12944 pub const fn empty() -> Self {
12945 Self(0)
12946 }
12947
12948 pub const REGULAR_GOP_BIT_KHR: Self = Self(1);
12949 pub const TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: Self = Self(2);
12950 pub const REFERENCE_PATTERN_FLAT_BIT_KHR: Self = Self(4);
12951 pub const REFERENCE_PATTERN_DYADIC_BIT_KHR: Self = Self(8);
12952}
12953
12954impl std::ops::BitOr for VideoEncodeAV1RateControlFlagBitsKHR {
12955 type Output = Self;
12956 fn bitor(self, rhs: Self) -> Self {
12957 Self(self.0 | rhs.0)
12958 }
12959}
12960
12961impl std::ops::BitAnd for VideoEncodeAV1RateControlFlagBitsKHR {
12962 type Output = Self;
12963 fn bitand(self, rhs: Self) -> Self {
12964 Self(self.0 & rhs.0)
12965 }
12966}
12967
12968impl std::ops::BitXor for VideoEncodeAV1RateControlFlagBitsKHR {
12969 type Output = Self;
12970 fn bitxor(self, rhs: Self) -> Self {
12971 Self(self.0 ^ rhs.0)
12972 }
12973}
12974
12975impl std::ops::Not for VideoEncodeAV1RateControlFlagBitsKHR {
12976 type Output = Self;
12977 fn not(self) -> Self {
12978 Self(!self.0)
12979 }
12980}
12981
12982#[repr(transparent)]
12983#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
12984pub struct VideoEncodeAV1SuperblockSizeFlagBitsKHR(pub u32);
12985impl VideoEncodeAV1SuperblockSizeFlagBitsKHR {
12986 pub const fn from_raw(value: u32) -> Self {
12987 Self(value)
12988 }
12989
12990 pub const fn as_raw(self) -> u32 {
12991 self.0
12992 }
12993
12994 pub const fn empty() -> Self {
12995 Self(0)
12996 }
12997
12998 pub const _64_BIT_KHR: Self = Self(1);
12999 pub const _128_BIT_KHR: Self = Self(2);
13000}
13001
13002impl std::ops::BitOr for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
13003 type Output = Self;
13004 fn bitor(self, rhs: Self) -> Self {
13005 Self(self.0 | rhs.0)
13006 }
13007}
13008
13009impl std::ops::BitAnd for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
13010 type Output = Self;
13011 fn bitand(self, rhs: Self) -> Self {
13012 Self(self.0 & rhs.0)
13013 }
13014}
13015
13016impl std::ops::BitXor for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
13017 type Output = Self;
13018 fn bitxor(self, rhs: Self) -> Self {
13019 Self(self.0 ^ rhs.0)
13020 }
13021}
13022
13023impl std::ops::Not for VideoEncodeAV1SuperblockSizeFlagBitsKHR {
13024 type Output = Self;
13025 fn not(self) -> Self {
13026 Self(!self.0)
13027 }
13028}
13029
13030#[repr(transparent)]
13031#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13032pub struct VideoEncodeAV1PredictionModeKHR(pub i32);
13033impl VideoEncodeAV1PredictionModeKHR {
13034 pub const fn from_raw(value: i32) -> Self {
13035 Self(value)
13036 }
13037
13038 pub const fn as_raw(self) -> i32 {
13039 self.0
13040 }
13041
13042 pub const fn empty() -> Self {
13043 Self(0)
13044 }
13045
13046 pub const INTRA_ONLY_KHR: Self = Self(0);
13047 pub const SINGLE_REFERENCE_KHR: Self = Self(1);
13048 pub const UNIDIRECTIONAL_COMPOUND_KHR: Self = Self(2);
13049 pub const BIDIRECTIONAL_COMPOUND_KHR: Self = Self(3);
13050}
13051
13052#[repr(transparent)]
13053#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13054pub struct VideoEncodeAV1RateControlGroupKHR(pub i32);
13055impl VideoEncodeAV1RateControlGroupKHR {
13056 pub const fn from_raw(value: i32) -> Self {
13057 Self(value)
13058 }
13059
13060 pub const fn as_raw(self) -> i32 {
13061 self.0
13062 }
13063
13064 pub const fn empty() -> Self {
13065 Self(0)
13066 }
13067
13068 pub const INTRA_KHR: Self = Self(0);
13069 pub const PREDICTIVE_KHR: Self = Self(1);
13070 pub const BIPREDICTIVE_KHR: Self = Self(2);
13071}
13072
13073#[cfg(feature = "platform-metal")]
13074#[repr(transparent)]
13075#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13076pub struct ExportMetalObjectTypeFlagBitsEXT(pub u32);
13077#[cfg(feature = "platform-metal")]
13078impl ExportMetalObjectTypeFlagBitsEXT {
13079 pub const fn from_raw(value: u32) -> Self {
13080 Self(value)
13081 }
13082
13083 pub const fn as_raw(self) -> u32 {
13084 self.0
13085 }
13086
13087 pub const fn empty() -> Self {
13088 Self(0)
13089 }
13090
13091 pub const METAL_DEVICE_BIT_EXT: Self = Self(1);
13092 pub const METAL_COMMAND_QUEUE_BIT_EXT: Self = Self(2);
13093 pub const METAL_BUFFER_BIT_EXT: Self = Self(4);
13094 pub const METAL_TEXTURE_BIT_EXT: Self = Self(8);
13095 pub const METAL_IOSURFACE_BIT_EXT: Self = Self(16);
13096 pub const METAL_SHARED_EVENT_BIT_EXT: Self = Self(32);
13097}
13098
13099#[cfg(feature = "platform-metal")]
13100impl std::ops::BitOr for ExportMetalObjectTypeFlagBitsEXT {
13101 type Output = Self;
13102 fn bitor(self, rhs: Self) -> Self {
13103 Self(self.0 | rhs.0)
13104 }
13105}
13106
13107#[cfg(feature = "platform-metal")]
13108impl std::ops::BitAnd for ExportMetalObjectTypeFlagBitsEXT {
13109 type Output = Self;
13110 fn bitand(self, rhs: Self) -> Self {
13111 Self(self.0 & rhs.0)
13112 }
13113}
13114
13115#[cfg(feature = "platform-metal")]
13116impl std::ops::BitXor for ExportMetalObjectTypeFlagBitsEXT {
13117 type Output = Self;
13118 fn bitxor(self, rhs: Self) -> Self {
13119 Self(self.0 ^ rhs.0)
13120 }
13121}
13122
13123#[cfg(feature = "platform-metal")]
13124impl std::ops::Not for ExportMetalObjectTypeFlagBitsEXT {
13125 type Output = Self;
13126 fn not(self) -> Self {
13127 Self(!self.0)
13128 }
13129}
13130
13131#[repr(transparent)]
13132#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13133pub struct InstanceCreateFlagBits(pub u32);
13134impl InstanceCreateFlagBits {
13135 pub const fn from_raw(value: u32) -> Self {
13136 Self(value)
13137 }
13138
13139 pub const fn as_raw(self) -> u32 {
13140 self.0
13141 }
13142
13143 pub const fn empty() -> Self {
13144 Self(0)
13145 }
13146
13147 pub const ENUMERATE_PORTABILITY_BIT_KHR: Self = Self(1);
13148}
13149
13150impl std::ops::BitOr for InstanceCreateFlagBits {
13151 type Output = Self;
13152 fn bitor(self, rhs: Self) -> Self {
13153 Self(self.0 | rhs.0)
13154 }
13155}
13156
13157impl std::ops::BitAnd for InstanceCreateFlagBits {
13158 type Output = Self;
13159 fn bitand(self, rhs: Self) -> Self {
13160 Self(self.0 & rhs.0)
13161 }
13162}
13163
13164impl std::ops::BitXor for InstanceCreateFlagBits {
13165 type Output = Self;
13166 fn bitxor(self, rhs: Self) -> Self {
13167 Self(self.0 ^ rhs.0)
13168 }
13169}
13170
13171impl std::ops::Not for InstanceCreateFlagBits {
13172 type Output = Self;
13173 fn not(self) -> Self {
13174 Self(!self.0)
13175 }
13176}
13177
13178#[repr(transparent)]
13179#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13180pub struct ImageCompressionFlagBitsEXT(pub u32);
13181impl ImageCompressionFlagBitsEXT {
13182 pub const fn from_raw(value: u32) -> Self {
13183 Self(value)
13184 }
13185
13186 pub const fn as_raw(self) -> u32 {
13187 self.0
13188 }
13189
13190 pub const fn empty() -> Self {
13191 Self(0)
13192 }
13193
13194 pub const DEFAULT_EXT: Self = Self(0);
13195 pub const FIXED_RATE_DEFAULT_EXT: Self = Self(1);
13196 pub const FIXED_RATE_EXPLICIT_EXT: Self = Self(2);
13197 pub const DISABLED_EXT: Self = Self(4);
13198}
13199
13200impl std::ops::BitOr for ImageCompressionFlagBitsEXT {
13201 type Output = Self;
13202 fn bitor(self, rhs: Self) -> Self {
13203 Self(self.0 | rhs.0)
13204 }
13205}
13206
13207impl std::ops::BitAnd for ImageCompressionFlagBitsEXT {
13208 type Output = Self;
13209 fn bitand(self, rhs: Self) -> Self {
13210 Self(self.0 & rhs.0)
13211 }
13212}
13213
13214impl std::ops::BitXor for ImageCompressionFlagBitsEXT {
13215 type Output = Self;
13216 fn bitxor(self, rhs: Self) -> Self {
13217 Self(self.0 ^ rhs.0)
13218 }
13219}
13220
13221impl std::ops::Not for ImageCompressionFlagBitsEXT {
13222 type Output = Self;
13223 fn not(self) -> Self {
13224 Self(!self.0)
13225 }
13226}
13227
13228#[repr(transparent)]
13229#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13230pub struct ImageCompressionFixedRateFlagBitsEXT(pub u32);
13231impl ImageCompressionFixedRateFlagBitsEXT {
13232 pub const fn from_raw(value: u32) -> Self {
13233 Self(value)
13234 }
13235
13236 pub const fn as_raw(self) -> u32 {
13237 self.0
13238 }
13239
13240 pub const fn empty() -> Self {
13241 Self(0)
13242 }
13243
13244 pub const NONE_EXT: Self = Self(0);
13245 pub const _1BPC_BIT_EXT: Self = Self(1);
13246 pub const _2BPC_BIT_EXT: Self = Self(2);
13247 pub const _3BPC_BIT_EXT: Self = Self(4);
13248 pub const _4BPC_BIT_EXT: Self = Self(8);
13249 pub const _5BPC_BIT_EXT: Self = Self(16);
13250 pub const _6BPC_BIT_EXT: Self = Self(32);
13251 pub const _7BPC_BIT_EXT: Self = Self(64);
13252 pub const _8BPC_BIT_EXT: Self = Self(128);
13253 pub const _9BPC_BIT_EXT: Self = Self(256);
13254 pub const _10BPC_BIT_EXT: Self = Self(512);
13255 pub const _11BPC_BIT_EXT: Self = Self(1024);
13256 pub const _12BPC_BIT_EXT: Self = Self(2048);
13257 pub const _13BPC_BIT_EXT: Self = Self(4096);
13258 pub const _14BPC_BIT_EXT: Self = Self(8192);
13259 pub const _15BPC_BIT_EXT: Self = Self(16384);
13260 pub const _16BPC_BIT_EXT: Self = Self(32768);
13261 pub const _17BPC_BIT_EXT: Self = Self(65536);
13262 pub const _18BPC_BIT_EXT: Self = Self(131072);
13263 pub const _19BPC_BIT_EXT: Self = Self(262144);
13264 pub const _20BPC_BIT_EXT: Self = Self(524288);
13265 pub const _21BPC_BIT_EXT: Self = Self(1048576);
13266 pub const _22BPC_BIT_EXT: Self = Self(2097152);
13267 pub const _23BPC_BIT_EXT: Self = Self(4194304);
13268 pub const _24BPC_BIT_EXT: Self = Self(8388608);
13269}
13270
13271impl std::ops::BitOr for ImageCompressionFixedRateFlagBitsEXT {
13272 type Output = Self;
13273 fn bitor(self, rhs: Self) -> Self {
13274 Self(self.0 | rhs.0)
13275 }
13276}
13277
13278impl std::ops::BitAnd for ImageCompressionFixedRateFlagBitsEXT {
13279 type Output = Self;
13280 fn bitand(self, rhs: Self) -> Self {
13281 Self(self.0 & rhs.0)
13282 }
13283}
13284
13285impl std::ops::BitXor for ImageCompressionFixedRateFlagBitsEXT {
13286 type Output = Self;
13287 fn bitxor(self, rhs: Self) -> Self {
13288 Self(self.0 ^ rhs.0)
13289 }
13290}
13291
13292impl std::ops::Not for ImageCompressionFixedRateFlagBitsEXT {
13293 type Output = Self;
13294 fn not(self) -> Self {
13295 Self(!self.0)
13296 }
13297}
13298
13299#[repr(transparent)]
13300#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13301pub struct PipelineRobustnessBufferBehavior(pub i32);
13302impl PipelineRobustnessBufferBehavior {
13303 pub const fn from_raw(value: i32) -> Self {
13304 Self(value)
13305 }
13306
13307 pub const fn as_raw(self) -> i32 {
13308 self.0
13309 }
13310
13311 pub const fn empty() -> Self {
13312 Self(0)
13313 }
13314
13315 pub const DEVICE_DEFAULT: Self = Self(0);
13316 pub const DISABLED: Self = Self(1);
13317 pub const ROBUST_BUFFER_ACCESS: Self = Self(2);
13318 pub const ROBUST_BUFFER_ACCESS_2: Self = Self(3);
13319 pub const DEVICE_DEFAULT_EXT: Self = Self(0);
13320 pub const DISABLED_EXT: Self = Self(1);
13321 pub const ROBUST_BUFFER_ACCESS_EXT: Self = Self(2);
13322 pub const ROBUST_BUFFER_ACCESS_2_EXT: Self = Self(3);
13323}
13324
13325#[repr(transparent)]
13326#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13327pub struct PipelineRobustnessImageBehavior(pub i32);
13328impl PipelineRobustnessImageBehavior {
13329 pub const fn from_raw(value: i32) -> Self {
13330 Self(value)
13331 }
13332
13333 pub const fn as_raw(self) -> i32 {
13334 self.0
13335 }
13336
13337 pub const fn empty() -> Self {
13338 Self(0)
13339 }
13340
13341 pub const DEVICE_DEFAULT: Self = Self(0);
13342 pub const DISABLED: Self = Self(1);
13343 pub const ROBUST_IMAGE_ACCESS: Self = Self(2);
13344 pub const ROBUST_IMAGE_ACCESS_2: Self = Self(3);
13345 pub const DEVICE_DEFAULT_EXT: Self = Self(0);
13346 pub const DISABLED_EXT: Self = Self(1);
13347 pub const ROBUST_IMAGE_ACCESS_EXT: Self = Self(2);
13348 pub const ROBUST_IMAGE_ACCESS_2_EXT: Self = Self(3);
13349}
13350
13351#[repr(transparent)]
13352#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13353pub struct OpticalFlowGridSizeFlagBitsNV(pub u32);
13354impl OpticalFlowGridSizeFlagBitsNV {
13355 pub const fn from_raw(value: u32) -> Self {
13356 Self(value)
13357 }
13358
13359 pub const fn as_raw(self) -> u32 {
13360 self.0
13361 }
13362
13363 pub const fn empty() -> Self {
13364 Self(0)
13365 }
13366
13367 pub const UNKNOWN_NV: Self = Self(0);
13368 pub const _1X1_BIT_NV: Self = Self(1);
13369 pub const _2X2_BIT_NV: Self = Self(2);
13370 pub const _4X4_BIT_NV: Self = Self(4);
13371 pub const _8X8_BIT_NV: Self = Self(8);
13372}
13373
13374impl std::ops::BitOr for OpticalFlowGridSizeFlagBitsNV {
13375 type Output = Self;
13376 fn bitor(self, rhs: Self) -> Self {
13377 Self(self.0 | rhs.0)
13378 }
13379}
13380
13381impl std::ops::BitAnd for OpticalFlowGridSizeFlagBitsNV {
13382 type Output = Self;
13383 fn bitand(self, rhs: Self) -> Self {
13384 Self(self.0 & rhs.0)
13385 }
13386}
13387
13388impl std::ops::BitXor for OpticalFlowGridSizeFlagBitsNV {
13389 type Output = Self;
13390 fn bitxor(self, rhs: Self) -> Self {
13391 Self(self.0 ^ rhs.0)
13392 }
13393}
13394
13395impl std::ops::Not for OpticalFlowGridSizeFlagBitsNV {
13396 type Output = Self;
13397 fn not(self) -> Self {
13398 Self(!self.0)
13399 }
13400}
13401
13402#[repr(transparent)]
13403#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13404pub struct OpticalFlowUsageFlagBitsNV(pub u32);
13405impl OpticalFlowUsageFlagBitsNV {
13406 pub const fn from_raw(value: u32) -> Self {
13407 Self(value)
13408 }
13409
13410 pub const fn as_raw(self) -> u32 {
13411 self.0
13412 }
13413
13414 pub const fn empty() -> Self {
13415 Self(0)
13416 }
13417
13418 pub const UNKNOWN_NV: Self = Self(0);
13419 pub const INPUT_BIT_NV: Self = Self(1);
13420 pub const OUTPUT_BIT_NV: Self = Self(2);
13421 pub const HINT_BIT_NV: Self = Self(4);
13422 pub const COST_BIT_NV: Self = Self(8);
13423 pub const GLOBAL_FLOW_BIT_NV: Self = Self(16);
13424}
13425
13426impl std::ops::BitOr for OpticalFlowUsageFlagBitsNV {
13427 type Output = Self;
13428 fn bitor(self, rhs: Self) -> Self {
13429 Self(self.0 | rhs.0)
13430 }
13431}
13432
13433impl std::ops::BitAnd for OpticalFlowUsageFlagBitsNV {
13434 type Output = Self;
13435 fn bitand(self, rhs: Self) -> Self {
13436 Self(self.0 & rhs.0)
13437 }
13438}
13439
13440impl std::ops::BitXor for OpticalFlowUsageFlagBitsNV {
13441 type Output = Self;
13442 fn bitxor(self, rhs: Self) -> Self {
13443 Self(self.0 ^ rhs.0)
13444 }
13445}
13446
13447impl std::ops::Not for OpticalFlowUsageFlagBitsNV {
13448 type Output = Self;
13449 fn not(self) -> Self {
13450 Self(!self.0)
13451 }
13452}
13453
13454#[repr(transparent)]
13455#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13456pub struct OpticalFlowPerformanceLevelNV(pub i32);
13457impl OpticalFlowPerformanceLevelNV {
13458 pub const fn from_raw(value: i32) -> Self {
13459 Self(value)
13460 }
13461
13462 pub const fn as_raw(self) -> i32 {
13463 self.0
13464 }
13465
13466 pub const fn empty() -> Self {
13467 Self(0)
13468 }
13469
13470 pub const UNKNOWN_NV: Self = Self(0);
13471 pub const SLOW_NV: Self = Self(1);
13472 pub const MEDIUM_NV: Self = Self(2);
13473 pub const FAST_NV: Self = Self(3);
13474}
13475
13476#[repr(transparent)]
13477#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13478pub struct OpticalFlowSessionBindingPointNV(pub i32);
13479impl OpticalFlowSessionBindingPointNV {
13480 pub const fn from_raw(value: i32) -> Self {
13481 Self(value)
13482 }
13483
13484 pub const fn as_raw(self) -> i32 {
13485 self.0
13486 }
13487
13488 pub const fn empty() -> Self {
13489 Self(0)
13490 }
13491
13492 pub const UNKNOWN_NV: Self = Self(0);
13493 pub const INPUT_NV: Self = Self(1);
13494 pub const REFERENCE_NV: Self = Self(2);
13495 pub const HINT_NV: Self = Self(3);
13496 pub const FLOW_VECTOR_NV: Self = Self(4);
13497 pub const BACKWARD_FLOW_VECTOR_NV: Self = Self(5);
13498 pub const COST_NV: Self = Self(6);
13499 pub const BACKWARD_COST_NV: Self = Self(7);
13500 pub const GLOBAL_FLOW_NV: Self = Self(8);
13501}
13502
13503#[repr(transparent)]
13504#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13505pub struct OpticalFlowSessionCreateFlagBitsNV(pub u32);
13506impl OpticalFlowSessionCreateFlagBitsNV {
13507 pub const fn from_raw(value: u32) -> Self {
13508 Self(value)
13509 }
13510
13511 pub const fn as_raw(self) -> u32 {
13512 self.0
13513 }
13514
13515 pub const fn empty() -> Self {
13516 Self(0)
13517 }
13518
13519 pub const ENABLE_HINT_BIT_NV: Self = Self(1);
13520 pub const ENABLE_COST_BIT_NV: Self = Self(2);
13521 pub const ENABLE_GLOBAL_FLOW_BIT_NV: Self = Self(4);
13522 pub const ALLOW_REGIONS_BIT_NV: Self = Self(8);
13523 pub const BOTH_DIRECTIONS_BIT_NV: Self = Self(16);
13524}
13525
13526impl std::ops::BitOr for OpticalFlowSessionCreateFlagBitsNV {
13527 type Output = Self;
13528 fn bitor(self, rhs: Self) -> Self {
13529 Self(self.0 | rhs.0)
13530 }
13531}
13532
13533impl std::ops::BitAnd for OpticalFlowSessionCreateFlagBitsNV {
13534 type Output = Self;
13535 fn bitand(self, rhs: Self) -> Self {
13536 Self(self.0 & rhs.0)
13537 }
13538}
13539
13540impl std::ops::BitXor for OpticalFlowSessionCreateFlagBitsNV {
13541 type Output = Self;
13542 fn bitxor(self, rhs: Self) -> Self {
13543 Self(self.0 ^ rhs.0)
13544 }
13545}
13546
13547impl std::ops::Not for OpticalFlowSessionCreateFlagBitsNV {
13548 type Output = Self;
13549 fn not(self) -> Self {
13550 Self(!self.0)
13551 }
13552}
13553
13554#[repr(transparent)]
13555#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13556pub struct OpticalFlowExecuteFlagBitsNV(pub u32);
13557impl OpticalFlowExecuteFlagBitsNV {
13558 pub const fn from_raw(value: u32) -> Self {
13559 Self(value)
13560 }
13561
13562 pub const fn as_raw(self) -> u32 {
13563 self.0
13564 }
13565
13566 pub const fn empty() -> Self {
13567 Self(0)
13568 }
13569
13570 pub const DISABLE_TEMPORAL_HINTS_BIT_NV: Self = Self(1);
13571}
13572
13573impl std::ops::BitOr for OpticalFlowExecuteFlagBitsNV {
13574 type Output = Self;
13575 fn bitor(self, rhs: Self) -> Self {
13576 Self(self.0 | rhs.0)
13577 }
13578}
13579
13580impl std::ops::BitAnd for OpticalFlowExecuteFlagBitsNV {
13581 type Output = Self;
13582 fn bitand(self, rhs: Self) -> Self {
13583 Self(self.0 & rhs.0)
13584 }
13585}
13586
13587impl std::ops::BitXor for OpticalFlowExecuteFlagBitsNV {
13588 type Output = Self;
13589 fn bitxor(self, rhs: Self) -> Self {
13590 Self(self.0 ^ rhs.0)
13591 }
13592}
13593
13594impl std::ops::Not for OpticalFlowExecuteFlagBitsNV {
13595 type Output = Self;
13596 fn not(self) -> Self {
13597 Self(!self.0)
13598 }
13599}
13600
13601#[repr(transparent)]
13602#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13603pub struct MicromapTypeEXT(pub i32);
13604impl MicromapTypeEXT {
13605 pub const fn from_raw(value: i32) -> Self {
13606 Self(value)
13607 }
13608
13609 pub const fn as_raw(self) -> i32 {
13610 self.0
13611 }
13612
13613 pub const fn empty() -> Self {
13614 Self(0)
13615 }
13616
13617 pub const OPACITY_MICROMAP_EXT: Self = Self(0);
13618 #[cfg(feature = "provisional")]
13619 pub const DISPLACEMENT_MICROMAP_NV: Self = Self(1000397000);
13620}
13621
13622#[repr(transparent)]
13623#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13624pub struct BuildMicromapFlagBitsEXT(pub u32);
13625impl BuildMicromapFlagBitsEXT {
13626 pub const fn from_raw(value: u32) -> Self {
13627 Self(value)
13628 }
13629
13630 pub const fn as_raw(self) -> u32 {
13631 self.0
13632 }
13633
13634 pub const fn empty() -> Self {
13635 Self(0)
13636 }
13637
13638 pub const PREFER_FAST_TRACE_BIT_EXT: Self = Self(1);
13639 pub const PREFER_FAST_BUILD_BIT_EXT: Self = Self(2);
13640 pub const ALLOW_COMPACTION_BIT_EXT: Self = Self(4);
13641}
13642
13643impl std::ops::BitOr for BuildMicromapFlagBitsEXT {
13644 type Output = Self;
13645 fn bitor(self, rhs: Self) -> Self {
13646 Self(self.0 | rhs.0)
13647 }
13648}
13649
13650impl std::ops::BitAnd for BuildMicromapFlagBitsEXT {
13651 type Output = Self;
13652 fn bitand(self, rhs: Self) -> Self {
13653 Self(self.0 & rhs.0)
13654 }
13655}
13656
13657impl std::ops::BitXor for BuildMicromapFlagBitsEXT {
13658 type Output = Self;
13659 fn bitxor(self, rhs: Self) -> Self {
13660 Self(self.0 ^ rhs.0)
13661 }
13662}
13663
13664impl std::ops::Not for BuildMicromapFlagBitsEXT {
13665 type Output = Self;
13666 fn not(self) -> Self {
13667 Self(!self.0)
13668 }
13669}
13670
13671#[repr(transparent)]
13672#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13673pub struct MicromapCreateFlagBitsEXT(pub u32);
13674impl MicromapCreateFlagBitsEXT {
13675 pub const fn from_raw(value: u32) -> Self {
13676 Self(value)
13677 }
13678
13679 pub const fn as_raw(self) -> u32 {
13680 self.0
13681 }
13682
13683 pub const fn empty() -> Self {
13684 Self(0)
13685 }
13686
13687 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: Self = Self(1);
13688}
13689
13690impl std::ops::BitOr for MicromapCreateFlagBitsEXT {
13691 type Output = Self;
13692 fn bitor(self, rhs: Self) -> Self {
13693 Self(self.0 | rhs.0)
13694 }
13695}
13696
13697impl std::ops::BitAnd for MicromapCreateFlagBitsEXT {
13698 type Output = Self;
13699 fn bitand(self, rhs: Self) -> Self {
13700 Self(self.0 & rhs.0)
13701 }
13702}
13703
13704impl std::ops::BitXor for MicromapCreateFlagBitsEXT {
13705 type Output = Self;
13706 fn bitxor(self, rhs: Self) -> Self {
13707 Self(self.0 ^ rhs.0)
13708 }
13709}
13710
13711impl std::ops::Not for MicromapCreateFlagBitsEXT {
13712 type Output = Self;
13713 fn not(self) -> Self {
13714 Self(!self.0)
13715 }
13716}
13717
13718#[repr(transparent)]
13719#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13720pub struct CopyMicromapModeEXT(pub i32);
13721impl CopyMicromapModeEXT {
13722 pub const fn from_raw(value: i32) -> Self {
13723 Self(value)
13724 }
13725
13726 pub const fn as_raw(self) -> i32 {
13727 self.0
13728 }
13729
13730 pub const fn empty() -> Self {
13731 Self(0)
13732 }
13733
13734 pub const CLONE_EXT: Self = Self(0);
13735 pub const SERIALIZE_EXT: Self = Self(1);
13736 pub const DESERIALIZE_EXT: Self = Self(2);
13737 pub const COMPACT_EXT: Self = Self(3);
13738}
13739
13740#[repr(transparent)]
13741#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13742pub struct BuildMicromapModeEXT(pub i32);
13743impl BuildMicromapModeEXT {
13744 pub const fn from_raw(value: i32) -> Self {
13745 Self(value)
13746 }
13747
13748 pub const fn as_raw(self) -> i32 {
13749 self.0
13750 }
13751
13752 pub const fn empty() -> Self {
13753 Self(0)
13754 }
13755
13756 pub const BUILD_EXT: Self = Self(0);
13757}
13758
13759#[repr(transparent)]
13760#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13761pub struct OpacityMicromapFormatKHR(pub i32);
13762impl OpacityMicromapFormatKHR {
13763 pub const fn from_raw(value: i32) -> Self {
13764 Self(value)
13765 }
13766
13767 pub const fn as_raw(self) -> i32 {
13768 self.0
13769 }
13770
13771 pub const fn empty() -> Self {
13772 Self(0)
13773 }
13774
13775 pub const _2_STATE_KHR: Self = Self(1);
13776 pub const _4_STATE_KHR: Self = Self(2);
13777 pub const _2_STATE_EXT: Self = Self(1);
13778 pub const _4_STATE_EXT: Self = Self(2);
13779}
13780
13781#[repr(transparent)]
13782#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13783pub struct OpacityMicromapSpecialIndexKHR(pub i32);
13784impl OpacityMicromapSpecialIndexKHR {
13785 pub const fn from_raw(value: i32) -> Self {
13786 Self(value)
13787 }
13788
13789 pub const fn as_raw(self) -> i32 {
13790 self.0
13791 }
13792
13793 pub const fn empty() -> Self {
13794 Self(0)
13795 }
13796
13797 pub const FULLY_TRANSPARENT_KHR: Self = Self(-1);
13798 pub const FULLY_OPAQUE_KHR: Self = Self(-2);
13799 pub const FULLY_UNKNOWN_TRANSPARENT_KHR: Self = Self(-3);
13800 pub const FULLY_UNKNOWN_OPAQUE_KHR: Self = Self(-4);
13801 pub const FULLY_TRANSPARENT_EXT: Self = Self(-1);
13802 pub const FULLY_OPAQUE_EXT: Self = Self(-2);
13803 pub const FULLY_UNKNOWN_TRANSPARENT_EXT: Self = Self(-3);
13804 pub const FULLY_UNKNOWN_OPAQUE_EXT: Self = Self(-4);
13805 pub const CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: Self = Self(-5);
13806}
13807
13808#[repr(transparent)]
13809#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13810pub struct AccelerationStructureSerializedBlockTypeKHR(pub i32);
13811impl AccelerationStructureSerializedBlockTypeKHR {
13812 pub const fn from_raw(value: i32) -> Self {
13813 Self(value)
13814 }
13815
13816 pub const fn as_raw(self) -> i32 {
13817 self.0
13818 }
13819
13820 pub const fn empty() -> Self {
13821 Self(0)
13822 }
13823
13824 pub const OPACITY_MICROMAP_KHR: Self = Self(0);
13825}
13826
13827#[repr(transparent)]
13828#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13829pub struct DepthBiasRepresentationEXT(pub i32);
13830impl DepthBiasRepresentationEXT {
13831 pub const fn from_raw(value: i32) -> Self {
13832 Self(value)
13833 }
13834
13835 pub const fn as_raw(self) -> i32 {
13836 self.0
13837 }
13838
13839 pub const fn empty() -> Self {
13840 Self(0)
13841 }
13842
13843 pub const LEAST_REPRESENTABLE_VALUE_FORMAT_EXT: Self = Self(0);
13844 pub const LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT: Self = Self(1);
13845 pub const FLOAT_EXT: Self = Self(2);
13846}
13847
13848#[repr(transparent)]
13849#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13850pub struct DeviceFaultFlagBitsKHR(pub u32);
13851impl DeviceFaultFlagBitsKHR {
13852 pub const fn from_raw(value: u32) -> Self {
13853 Self(value)
13854 }
13855
13856 pub const fn as_raw(self) -> u32 {
13857 self.0
13858 }
13859
13860 pub const fn empty() -> Self {
13861 Self(0)
13862 }
13863
13864 pub const FLAG_DEVICE_LOST_KHR: Self = Self(1);
13865 pub const FLAG_MEMORY_ADDRESS_KHR: Self = Self(2);
13866 pub const FLAG_INSTRUCTION_ADDRESS_KHR: Self = Self(4);
13867 pub const FLAG_VENDOR_KHR: Self = Self(8);
13868 pub const FLAG_WATCHDOG_TIMEOUT_KHR: Self = Self(16);
13869 pub const FLAG_OVERFLOW_KHR: Self = Self(32);
13870}
13871
13872impl std::ops::BitOr for DeviceFaultFlagBitsKHR {
13873 type Output = Self;
13874 fn bitor(self, rhs: Self) -> Self {
13875 Self(self.0 | rhs.0)
13876 }
13877}
13878
13879impl std::ops::BitAnd for DeviceFaultFlagBitsKHR {
13880 type Output = Self;
13881 fn bitand(self, rhs: Self) -> Self {
13882 Self(self.0 & rhs.0)
13883 }
13884}
13885
13886impl std::ops::BitXor for DeviceFaultFlagBitsKHR {
13887 type Output = Self;
13888 fn bitxor(self, rhs: Self) -> Self {
13889 Self(self.0 ^ rhs.0)
13890 }
13891}
13892
13893impl std::ops::Not for DeviceFaultFlagBitsKHR {
13894 type Output = Self;
13895 fn not(self) -> Self {
13896 Self(!self.0)
13897 }
13898}
13899
13900#[repr(transparent)]
13901#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13902pub struct DeviceFaultAddressTypeKHR(pub i32);
13903impl DeviceFaultAddressTypeKHR {
13904 pub const fn from_raw(value: i32) -> Self {
13905 Self(value)
13906 }
13907
13908 pub const fn as_raw(self) -> i32 {
13909 self.0
13910 }
13911
13912 pub const fn empty() -> Self {
13913 Self(0)
13914 }
13915
13916 pub const NONE_KHR: Self = Self(0);
13917 pub const READ_INVALID_KHR: Self = Self(1);
13918 pub const WRITE_INVALID_KHR: Self = Self(2);
13919 pub const EXECUTE_INVALID_KHR: Self = Self(3);
13920 pub const INSTRUCTION_POINTER_UNKNOWN_KHR: Self = Self(4);
13921 pub const INSTRUCTION_POINTER_INVALID_KHR: Self = Self(5);
13922 pub const INSTRUCTION_POINTER_FAULT_KHR: Self = Self(6);
13923 pub const NONE_EXT: Self = Self(0);
13924 pub const READ_INVALID_EXT: Self = Self(1);
13925 pub const WRITE_INVALID_EXT: Self = Self(2);
13926 pub const EXECUTE_INVALID_EXT: Self = Self(3);
13927 pub const INSTRUCTION_POINTER_UNKNOWN_EXT: Self = Self(4);
13928 pub const INSTRUCTION_POINTER_INVALID_EXT: Self = Self(5);
13929 pub const INSTRUCTION_POINTER_FAULT_EXT: Self = Self(6);
13930}
13931
13932#[repr(transparent)]
13933#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13934pub struct DeviceFaultVendorBinaryHeaderVersionKHR(pub i32);
13935impl DeviceFaultVendorBinaryHeaderVersionKHR {
13936 pub const fn from_raw(value: i32) -> Self {
13937 Self(value)
13938 }
13939
13940 pub const fn as_raw(self) -> i32 {
13941 self.0
13942 }
13943
13944 pub const fn empty() -> Self {
13945 Self(0)
13946 }
13947
13948 pub const ONE_KHR: Self = Self(1);
13949 pub const ONE_EXT: Self = Self(1);
13950}
13951
13952#[repr(transparent)]
13953#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
13954pub struct IndirectCommandsLayoutUsageFlagBitsEXT(pub u32);
13955impl IndirectCommandsLayoutUsageFlagBitsEXT {
13956 pub const fn from_raw(value: u32) -> Self {
13957 Self(value)
13958 }
13959
13960 pub const fn as_raw(self) -> u32 {
13961 self.0
13962 }
13963
13964 pub const fn empty() -> Self {
13965 Self(0)
13966 }
13967
13968 pub const EXPLICIT_PREPROCESS_BIT_EXT: Self = Self(1);
13969 pub const UNORDERED_SEQUENCES_BIT_EXT: Self = Self(2);
13970}
13971
13972impl std::ops::BitOr for IndirectCommandsLayoutUsageFlagBitsEXT {
13973 type Output = Self;
13974 fn bitor(self, rhs: Self) -> Self {
13975 Self(self.0 | rhs.0)
13976 }
13977}
13978
13979impl std::ops::BitAnd for IndirectCommandsLayoutUsageFlagBitsEXT {
13980 type Output = Self;
13981 fn bitand(self, rhs: Self) -> Self {
13982 Self(self.0 & rhs.0)
13983 }
13984}
13985
13986impl std::ops::BitXor for IndirectCommandsLayoutUsageFlagBitsEXT {
13987 type Output = Self;
13988 fn bitxor(self, rhs: Self) -> Self {
13989 Self(self.0 ^ rhs.0)
13990 }
13991}
13992
13993impl std::ops::Not for IndirectCommandsLayoutUsageFlagBitsEXT {
13994 type Output = Self;
13995 fn not(self) -> Self {
13996 Self(!self.0)
13997 }
13998}
13999
14000#[repr(transparent)]
14001#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14002pub struct IndirectExecutionSetInfoTypeEXT(pub i32);
14003impl IndirectExecutionSetInfoTypeEXT {
14004 pub const fn from_raw(value: i32) -> Self {
14005 Self(value)
14006 }
14007
14008 pub const fn as_raw(self) -> i32 {
14009 self.0
14010 }
14011
14012 pub const fn empty() -> Self {
14013 Self(0)
14014 }
14015
14016 pub const PIPELINES_EXT: Self = Self(0);
14017 pub const SHADER_OBJECTS_EXT: Self = Self(1);
14018}
14019
14020#[repr(transparent)]
14021#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14022pub struct IndirectCommandsInputModeFlagBitsEXT(pub u32);
14023impl IndirectCommandsInputModeFlagBitsEXT {
14024 pub const fn from_raw(value: u32) -> Self {
14025 Self(value)
14026 }
14027
14028 pub const fn as_raw(self) -> u32 {
14029 self.0
14030 }
14031
14032 pub const fn empty() -> Self {
14033 Self(0)
14034 }
14035
14036 pub const VULKAN_INDEX_BUFFER_EXT: Self = Self(1);
14037 pub const DXGI_INDEX_BUFFER_EXT: Self = Self(2);
14038}
14039
14040impl std::ops::BitOr for IndirectCommandsInputModeFlagBitsEXT {
14041 type Output = Self;
14042 fn bitor(self, rhs: Self) -> Self {
14043 Self(self.0 | rhs.0)
14044 }
14045}
14046
14047impl std::ops::BitAnd for IndirectCommandsInputModeFlagBitsEXT {
14048 type Output = Self;
14049 fn bitand(self, rhs: Self) -> Self {
14050 Self(self.0 & rhs.0)
14051 }
14052}
14053
14054impl std::ops::BitXor for IndirectCommandsInputModeFlagBitsEXT {
14055 type Output = Self;
14056 fn bitxor(self, rhs: Self) -> Self {
14057 Self(self.0 ^ rhs.0)
14058 }
14059}
14060
14061impl std::ops::Not for IndirectCommandsInputModeFlagBitsEXT {
14062 type Output = Self;
14063 fn not(self) -> Self {
14064 Self(!self.0)
14065 }
14066}
14067
14068#[repr(transparent)]
14069#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14070pub struct IndirectCommandsTokenTypeEXT(pub i32);
14071impl IndirectCommandsTokenTypeEXT {
14072 pub const fn from_raw(value: i32) -> Self {
14073 Self(value)
14074 }
14075
14076 pub const fn as_raw(self) -> i32 {
14077 self.0
14078 }
14079
14080 pub const fn empty() -> Self {
14081 Self(0)
14082 }
14083
14084 pub const EXECUTION_SET_EXT: Self = Self(0);
14085 pub const PUSH_CONSTANT_EXT: Self = Self(1);
14086 pub const SEQUENCE_INDEX_EXT: Self = Self(2);
14087 pub const INDEX_BUFFER_EXT: Self = Self(3);
14088 pub const VERTEX_BUFFER_EXT: Self = Self(4);
14089 pub const DRAW_INDEXED_EXT: Self = Self(5);
14090 pub const DRAW_EXT: Self = Self(6);
14091 pub const DRAW_INDEXED_COUNT_EXT: Self = Self(7);
14092 pub const DRAW_COUNT_EXT: Self = Self(8);
14093 pub const DISPATCH_EXT: Self = Self(9);
14094 pub const PUSH_DATA_EXT: Self = Self(1000135000);
14095 pub const PUSH_DATA_SEQUENCE_INDEX_EXT: Self = Self(1000135001);
14096 pub const DRAW_MESH_TASKS_NV_EXT: Self = Self(1000202002);
14097 pub const DRAW_MESH_TASKS_COUNT_NV_EXT: Self = Self(1000202003);
14098 pub const DRAW_MESH_TASKS_EXT: Self = Self(1000328000);
14099 pub const DRAW_MESH_TASKS_COUNT_EXT: Self = Self(1000328001);
14100 pub const TRACE_RAYS2_EXT: Self = Self(1000386004);
14101}
14102
14103#[cfg(feature = "provisional")]
14104#[repr(transparent)]
14105#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14106pub struct DisplacementMicromapFormatNV(pub i32);
14107#[cfg(feature = "provisional")]
14108impl DisplacementMicromapFormatNV {
14109 pub const fn from_raw(value: i32) -> Self {
14110 Self(value)
14111 }
14112
14113 pub const fn as_raw(self) -> i32 {
14114 self.0
14115 }
14116
14117 pub const fn empty() -> Self {
14118 Self(0)
14119 }
14120
14121 pub const _64_TRIANGLES_64_BYTES_NV: Self = Self(1);
14122 pub const _256_TRIANGLES_128_BYTES_NV: Self = Self(2);
14123 pub const _1024_TRIANGLES_128_BYTES_NV: Self = Self(3);
14124}
14125
14126#[repr(transparent)]
14127#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14128pub struct ShaderCreateFlagBitsEXT(pub u32);
14129impl ShaderCreateFlagBitsEXT {
14130 pub const fn from_raw(value: u32) -> Self {
14131 Self(value)
14132 }
14133
14134 pub const fn as_raw(self) -> u32 {
14135 self.0
14136 }
14137
14138 pub const fn empty() -> Self {
14139 Self(0)
14140 }
14141
14142 pub const LINK_STAGE_BIT_EXT: Self = Self(1);
14143 pub const DESCRIPTOR_HEAP_BIT_EXT: Self = Self(1024);
14144 pub const INSTRUMENT_SHADER_BIT_ARM: Self = Self(2048);
14145 pub const ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: Self = Self(2);
14146 pub const REQUIRE_FULL_SUBGROUPS_BIT_EXT: Self = Self(4);
14147 pub const NO_TASK_SHADER_BIT_EXT: Self = Self(8);
14148 pub const DISPATCH_BASE_BIT_EXT: Self = Self(16);
14149 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT: Self = Self(32);
14150 pub const FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: Self = Self(64);
14151 pub const INDIRECT_BINDABLE_BIT_EXT: Self = Self(128);
14152 pub const OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT: Self = Self(4096);
14153 pub const _64_BIT_INDEXING_BIT_EXT: Self = Self(32768);
14154 pub const INDEPENDENT_SETS_BIT_KHR: Self = Self(262144);
14155}
14156
14157impl std::ops::BitOr for ShaderCreateFlagBitsEXT {
14158 type Output = Self;
14159 fn bitor(self, rhs: Self) -> Self {
14160 Self(self.0 | rhs.0)
14161 }
14162}
14163
14164impl std::ops::BitAnd for ShaderCreateFlagBitsEXT {
14165 type Output = Self;
14166 fn bitand(self, rhs: Self) -> Self {
14167 Self(self.0 & rhs.0)
14168 }
14169}
14170
14171impl std::ops::BitXor for ShaderCreateFlagBitsEXT {
14172 type Output = Self;
14173 fn bitxor(self, rhs: Self) -> Self {
14174 Self(self.0 ^ rhs.0)
14175 }
14176}
14177
14178impl std::ops::Not for ShaderCreateFlagBitsEXT {
14179 type Output = Self;
14180 fn not(self) -> Self {
14181 Self(!self.0)
14182 }
14183}
14184
14185#[repr(transparent)]
14186#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14187pub struct ShaderCodeTypeEXT(pub i32);
14188impl ShaderCodeTypeEXT {
14189 pub const fn from_raw(value: i32) -> Self {
14190 Self(value)
14191 }
14192
14193 pub const fn as_raw(self) -> i32 {
14194 self.0
14195 }
14196
14197 pub const fn empty() -> Self {
14198 Self(0)
14199 }
14200
14201 pub const BINARY_EXT: Self = Self(0);
14202 pub const SPIRV_EXT: Self = Self(1);
14203}
14204
14205#[repr(transparent)]
14206#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14207pub struct ScopeKHR(pub i32);
14208impl ScopeKHR {
14209 pub const fn from_raw(value: i32) -> Self {
14210 Self(value)
14211 }
14212
14213 pub const fn as_raw(self) -> i32 {
14214 self.0
14215 }
14216
14217 pub const fn empty() -> Self {
14218 Self(0)
14219 }
14220
14221 pub const DEVICE_KHR: Self = Self(1);
14222 pub const WORKGROUP_KHR: Self = Self(2);
14223 pub const SUBGROUP_KHR: Self = Self(3);
14224 pub const QUEUE_FAMILY_KHR: Self = Self(5);
14225 pub const DEVICE_NV: Self = Self(1);
14226 pub const WORKGROUP_NV: Self = Self(2);
14227 pub const SUBGROUP_NV: Self = Self(3);
14228 pub const QUEUE_FAMILY_NV: Self = Self(5);
14229}
14230
14231#[repr(transparent)]
14232#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14233pub struct ComponentTypeKHR(pub i32);
14234impl ComponentTypeKHR {
14235 pub const fn from_raw(value: i32) -> Self {
14236 Self(value)
14237 }
14238
14239 pub const fn as_raw(self) -> i32 {
14240 self.0
14241 }
14242
14243 pub const fn empty() -> Self {
14244 Self(0)
14245 }
14246
14247 pub const FLOAT16_KHR: Self = Self(0);
14248 pub const FLOAT32_KHR: Self = Self(1);
14249 pub const FLOAT64_KHR: Self = Self(2);
14250 pub const SINT8_KHR: Self = Self(3);
14251 pub const SINT16_KHR: Self = Self(4);
14252 pub const SINT32_KHR: Self = Self(5);
14253 pub const SINT64_KHR: Self = Self(6);
14254 pub const UINT8_KHR: Self = Self(7);
14255 pub const UINT16_KHR: Self = Self(8);
14256 pub const UINT32_KHR: Self = Self(9);
14257 pub const UINT64_KHR: Self = Self(10);
14258 pub const BFLOAT16_KHR: Self = Self(1000141000);
14259 pub const FLOAT16_NV: Self = Self(0);
14260 pub const FLOAT32_NV: Self = Self(1);
14261 pub const FLOAT64_NV: Self = Self(2);
14262 pub const SINT8_NV: Self = Self(3);
14263 pub const SINT16_NV: Self = Self(4);
14264 pub const SINT32_NV: Self = Self(5);
14265 pub const SINT64_NV: Self = Self(6);
14266 pub const UINT8_NV: Self = Self(7);
14267 pub const UINT16_NV: Self = Self(8);
14268 pub const UINT32_NV: Self = Self(9);
14269 pub const UINT64_NV: Self = Self(10);
14270 pub const SINT8_PACKED_NV: Self = Self(1000491000);
14271 pub const UINT8_PACKED_NV: Self = Self(1000491001);
14272 pub const FLOAT_E4M3_NV: Self = Self(1000491002);
14273 pub const FLOAT_E5M2_NV: Self = Self(1000491003);
14274 pub const FLOAT8_E4M3_EXT: Self = Self(1000491002);
14275 pub const FLOAT8_E5M2_EXT: Self = Self(1000491003);
14276 pub const FLOAT6_E2M3_EXT: Self = Self(1000672000);
14277 pub const FLOAT6_E3M2_EXT: Self = Self(1000672001);
14278 pub const FLOAT4_E2M1_EXT: Self = Self(1000672002);
14279 pub const FLOAT8_UNSIGNED_E8M0_EXT: Self = Self(1000672003);
14280 pub const MXINT8_EXT: Self = Self(1000672004);
14281}
14282
14283#[repr(transparent)]
14284#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14285pub struct CubicFilterWeightsQCOM(pub i32);
14286impl CubicFilterWeightsQCOM {
14287 pub const fn from_raw(value: i32) -> Self {
14288 Self(value)
14289 }
14290
14291 pub const fn as_raw(self) -> i32 {
14292 self.0
14293 }
14294
14295 pub const fn empty() -> Self {
14296 Self(0)
14297 }
14298
14299 pub const CATMULL_ROM_QCOM: Self = Self(0);
14300 pub const ZERO_TANGENT_CARDINAL_QCOM: Self = Self(1);
14301 pub const B_SPLINE_QCOM: Self = Self(2);
14302 pub const MITCHELL_NETRAVALI_QCOM: Self = Self(3);
14303}
14304
14305#[repr(transparent)]
14306#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14307pub struct BlockMatchWindowCompareModeQCOM(pub i32);
14308impl BlockMatchWindowCompareModeQCOM {
14309 pub const fn from_raw(value: i32) -> Self {
14310 Self(value)
14311 }
14312
14313 pub const fn as_raw(self) -> i32 {
14314 self.0
14315 }
14316
14317 pub const fn empty() -> Self {
14318 Self(0)
14319 }
14320
14321 pub const MIN_QCOM: Self = Self(0);
14322 pub const MAX_QCOM: Self = Self(1);
14323}
14324
14325#[repr(transparent)]
14326#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14327pub struct PhysicalDeviceLayeredApiKHR(pub i32);
14328impl PhysicalDeviceLayeredApiKHR {
14329 pub const fn from_raw(value: i32) -> Self {
14330 Self(value)
14331 }
14332
14333 pub const fn as_raw(self) -> i32 {
14334 self.0
14335 }
14336
14337 pub const fn empty() -> Self {
14338 Self(0)
14339 }
14340
14341 pub const VULKAN_KHR: Self = Self(0);
14342 pub const D3D12_KHR: Self = Self(1);
14343 pub const METAL_KHR: Self = Self(2);
14344 pub const OPENGL_KHR: Self = Self(3);
14345 pub const OPENGLES_KHR: Self = Self(4);
14346}
14347
14348#[repr(transparent)]
14349#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14350pub struct LayeredDriverUnderlyingApiMSFT(pub i32);
14351impl LayeredDriverUnderlyingApiMSFT {
14352 pub const fn from_raw(value: i32) -> Self {
14353 Self(value)
14354 }
14355
14356 pub const fn as_raw(self) -> i32 {
14357 self.0
14358 }
14359
14360 pub const fn empty() -> Self {
14361 Self(0)
14362 }
14363
14364 pub const LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT: Self = Self(0);
14365 pub const LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT: Self = Self(1);
14366}
14367
14368#[repr(transparent)]
14369#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14370pub struct LatencyMarkerNV(pub i32);
14371impl LatencyMarkerNV {
14372 pub const fn from_raw(value: i32) -> Self {
14373 Self(value)
14374 }
14375
14376 pub const fn as_raw(self) -> i32 {
14377 self.0
14378 }
14379
14380 pub const fn empty() -> Self {
14381 Self(0)
14382 }
14383
14384 pub const SIMULATION_START_NV: Self = Self(0);
14385 pub const SIMULATION_END_NV: Self = Self(1);
14386 pub const RENDERSUBMIT_START_NV: Self = Self(2);
14387 pub const RENDERSUBMIT_END_NV: Self = Self(3);
14388 pub const PRESENT_START_NV: Self = Self(4);
14389 pub const PRESENT_END_NV: Self = Self(5);
14390 pub const INPUT_SAMPLE_NV: Self = Self(6);
14391 pub const TRIGGER_FLASH_NV: Self = Self(7);
14392 pub const OUT_OF_BAND_RENDERSUBMIT_START_NV: Self = Self(8);
14393 pub const OUT_OF_BAND_RENDERSUBMIT_END_NV: Self = Self(9);
14394 pub const OUT_OF_BAND_PRESENT_START_NV: Self = Self(10);
14395 pub const OUT_OF_BAND_PRESENT_END_NV: Self = Self(11);
14396}
14397
14398#[repr(transparent)]
14399#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14400pub struct OutOfBandQueueTypeNV(pub i32);
14401impl OutOfBandQueueTypeNV {
14402 pub const fn from_raw(value: i32) -> Self {
14403 Self(value)
14404 }
14405
14406 pub const fn as_raw(self) -> i32 {
14407 self.0
14408 }
14409
14410 pub const fn empty() -> Self {
14411 Self(0)
14412 }
14413
14414 pub const RENDER_NV: Self = Self(0);
14415 pub const PRESENT_NV: Self = Self(1);
14416}
14417
14418#[repr(transparent)]
14419#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14420pub struct MemoryUnmapFlagBits(pub u32);
14421impl MemoryUnmapFlagBits {
14422 pub const fn from_raw(value: u32) -> Self {
14423 Self(value)
14424 }
14425
14426 pub const fn as_raw(self) -> u32 {
14427 self.0
14428 }
14429
14430 pub const fn empty() -> Self {
14431 Self(0)
14432 }
14433
14434 pub const RESERVE_BIT_EXT: Self = Self(1);
14435}
14436
14437impl std::ops::BitOr for MemoryUnmapFlagBits {
14438 type Output = Self;
14439 fn bitor(self, rhs: Self) -> Self {
14440 Self(self.0 | rhs.0)
14441 }
14442}
14443
14444impl std::ops::BitAnd for MemoryUnmapFlagBits {
14445 type Output = Self;
14446 fn bitand(self, rhs: Self) -> Self {
14447 Self(self.0 & rhs.0)
14448 }
14449}
14450
14451impl std::ops::BitXor for MemoryUnmapFlagBits {
14452 type Output = Self;
14453 fn bitxor(self, rhs: Self) -> Self {
14454 Self(self.0 ^ rhs.0)
14455 }
14456}
14457
14458impl std::ops::Not for MemoryUnmapFlagBits {
14459 type Output = Self;
14460 fn not(self) -> Self {
14461 Self(!self.0)
14462 }
14463}
14464
14465#[cfg(feature = "provisional")]
14466#[repr(transparent)]
14467#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14468pub struct CompressedTriangleFormatAMDX(pub i32);
14469#[cfg(feature = "provisional")]
14470impl CompressedTriangleFormatAMDX {
14471 pub const fn from_raw(value: i32) -> Self {
14472 Self(value)
14473 }
14474
14475 pub const fn as_raw(self) -> i32 {
14476 self.0
14477 }
14478
14479 pub const fn empty() -> Self {
14480 Self(0)
14481 }
14482
14483 pub const COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX: Self = Self(0);
14484}
14485
14486#[repr(transparent)]
14487#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14488pub struct DepthClampModeEXT(pub i32);
14489impl DepthClampModeEXT {
14490 pub const fn from_raw(value: i32) -> Self {
14491 Self(value)
14492 }
14493
14494 pub const fn as_raw(self) -> i32 {
14495 self.0
14496 }
14497
14498 pub const fn empty() -> Self {
14499 Self(0)
14500 }
14501
14502 pub const VIEWPORT_RANGE_EXT: Self = Self(0);
14503 pub const USER_DEFINED_RANGE_EXT: Self = Self(1);
14504}
14505
14506#[repr(transparent)]
14507#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14508pub struct AccessFlagBits3KHR(pub u64);
14509impl AccessFlagBits3KHR {
14510 pub const fn from_raw(value: u64) -> Self {
14511 Self(value)
14512 }
14513
14514 pub const fn as_raw(self) -> u64 {
14515 self.0
14516 }
14517
14518 pub const fn empty() -> Self {
14519 Self(0)
14520 }
14521
14522 pub const NONE_KHR: Self = Self(0);
14523}
14524
14525impl std::ops::BitOr for AccessFlagBits3KHR {
14526 type Output = Self;
14527 fn bitor(self, rhs: Self) -> Self {
14528 Self(self.0 | rhs.0)
14529 }
14530}
14531
14532impl std::ops::BitAnd for AccessFlagBits3KHR {
14533 type Output = Self;
14534 fn bitand(self, rhs: Self) -> Self {
14535 Self(self.0 & rhs.0)
14536 }
14537}
14538
14539impl std::ops::BitXor for AccessFlagBits3KHR {
14540 type Output = Self;
14541 fn bitxor(self, rhs: Self) -> Self {
14542 Self(self.0 ^ rhs.0)
14543 }
14544}
14545
14546impl std::ops::Not for AccessFlagBits3KHR {
14547 type Output = Self;
14548 fn not(self) -> Self {
14549 Self(!self.0)
14550 }
14551}
14552
14553#[repr(transparent)]
14554#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14555pub struct TileShadingRenderPassFlagBitsQCOM(pub u32);
14556impl TileShadingRenderPassFlagBitsQCOM {
14557 pub const fn from_raw(value: u32) -> Self {
14558 Self(value)
14559 }
14560
14561 pub const fn as_raw(self) -> u32 {
14562 self.0
14563 }
14564
14565 pub const fn empty() -> Self {
14566 Self(0)
14567 }
14568
14569 pub const ENABLE_BIT_QCOM: Self = Self(1);
14570 pub const PER_TILE_EXECUTION_BIT_QCOM: Self = Self(2);
14571}
14572
14573impl std::ops::BitOr for TileShadingRenderPassFlagBitsQCOM {
14574 type Output = Self;
14575 fn bitor(self, rhs: Self) -> Self {
14576 Self(self.0 | rhs.0)
14577 }
14578}
14579
14580impl std::ops::BitAnd for TileShadingRenderPassFlagBitsQCOM {
14581 type Output = Self;
14582 fn bitand(self, rhs: Self) -> Self {
14583 Self(self.0 & rhs.0)
14584 }
14585}
14586
14587impl std::ops::BitXor for TileShadingRenderPassFlagBitsQCOM {
14588 type Output = Self;
14589 fn bitxor(self, rhs: Self) -> Self {
14590 Self(self.0 ^ rhs.0)
14591 }
14592}
14593
14594impl std::ops::Not for TileShadingRenderPassFlagBitsQCOM {
14595 type Output = Self;
14596 fn not(self) -> Self {
14597 Self(!self.0)
14598 }
14599}
14600
14601#[repr(transparent)]
14602#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14603pub struct CooperativeVectorMatrixLayoutNV(pub i32);
14604impl CooperativeVectorMatrixLayoutNV {
14605 pub const fn from_raw(value: i32) -> Self {
14606 Self(value)
14607 }
14608
14609 pub const fn as_raw(self) -> i32 {
14610 self.0
14611 }
14612
14613 pub const fn empty() -> Self {
14614 Self(0)
14615 }
14616
14617 pub const ROW_MAJOR_NV: Self = Self(0);
14618 pub const COLUMN_MAJOR_NV: Self = Self(1);
14619 pub const INFERENCING_OPTIMAL_NV: Self = Self(2);
14620 pub const TRAINING_OPTIMAL_NV: Self = Self(3);
14621}
14622
14623#[repr(transparent)]
14624#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14625pub struct AddressCopyFlagBitsKHR(pub u32);
14626impl AddressCopyFlagBitsKHR {
14627 pub const fn from_raw(value: u32) -> Self {
14628 Self(value)
14629 }
14630
14631 pub const fn as_raw(self) -> u32 {
14632 self.0
14633 }
14634
14635 pub const fn empty() -> Self {
14636 Self(0)
14637 }
14638
14639 pub const DEVICE_LOCAL_BIT_KHR: Self = Self(1);
14640 pub const SPARSE_BIT_KHR: Self = Self(2);
14641 pub const PROTECTED_BIT_KHR: Self = Self(4);
14642}
14643
14644impl std::ops::BitOr for AddressCopyFlagBitsKHR {
14645 type Output = Self;
14646 fn bitor(self, rhs: Self) -> Self {
14647 Self(self.0 | rhs.0)
14648 }
14649}
14650
14651impl std::ops::BitAnd for AddressCopyFlagBitsKHR {
14652 type Output = Self;
14653 fn bitand(self, rhs: Self) -> Self {
14654 Self(self.0 & rhs.0)
14655 }
14656}
14657
14658impl std::ops::BitXor for AddressCopyFlagBitsKHR {
14659 type Output = Self;
14660 fn bitxor(self, rhs: Self) -> Self {
14661 Self(self.0 ^ rhs.0)
14662 }
14663}
14664
14665impl std::ops::Not for AddressCopyFlagBitsKHR {
14666 type Output = Self;
14667 fn not(self) -> Self {
14668 Self(!self.0)
14669 }
14670}
14671
14672#[repr(transparent)]
14673#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14674pub struct TensorCreateFlagBitsARM(pub u64);
14675impl TensorCreateFlagBitsARM {
14676 pub const fn from_raw(value: u64) -> Self {
14677 Self(value)
14678 }
14679
14680 pub const fn as_raw(self) -> u64 {
14681 self.0
14682 }
14683
14684 pub const fn empty() -> Self {
14685 Self(0)
14686 }
14687
14688 pub const MUTABLE_FORMAT_BIT_ARM: Self = Self(1);
14689 pub const PROTECTED_BIT_ARM: Self = Self(2);
14690 pub const DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM: Self = Self(8);
14691 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: Self = Self(4);
14692}
14693
14694impl std::ops::BitOr for TensorCreateFlagBitsARM {
14695 type Output = Self;
14696 fn bitor(self, rhs: Self) -> Self {
14697 Self(self.0 | rhs.0)
14698 }
14699}
14700
14701impl std::ops::BitAnd for TensorCreateFlagBitsARM {
14702 type Output = Self;
14703 fn bitand(self, rhs: Self) -> Self {
14704 Self(self.0 & rhs.0)
14705 }
14706}
14707
14708impl std::ops::BitXor for TensorCreateFlagBitsARM {
14709 type Output = Self;
14710 fn bitxor(self, rhs: Self) -> Self {
14711 Self(self.0 ^ rhs.0)
14712 }
14713}
14714
14715impl std::ops::Not for TensorCreateFlagBitsARM {
14716 type Output = Self;
14717 fn not(self) -> Self {
14718 Self(!self.0)
14719 }
14720}
14721
14722#[repr(transparent)]
14723#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14724pub struct TensorUsageFlagBitsARM(pub u64);
14725impl TensorUsageFlagBitsARM {
14726 pub const fn from_raw(value: u64) -> Self {
14727 Self(value)
14728 }
14729
14730 pub const fn as_raw(self) -> u64 {
14731 self.0
14732 }
14733
14734 pub const fn empty() -> Self {
14735 Self(0)
14736 }
14737
14738 pub const SHADER_BIT_ARM: Self = Self(2);
14739 pub const TRANSFER_SRC_BIT_ARM: Self = Self(4);
14740 pub const TRANSFER_DST_BIT_ARM: Self = Self(8);
14741 pub const IMAGE_ALIASING_BIT_ARM: Self = Self(16);
14742 pub const DATA_GRAPH_BIT_ARM: Self = Self(32);
14743}
14744
14745impl std::ops::BitOr for TensorUsageFlagBitsARM {
14746 type Output = Self;
14747 fn bitor(self, rhs: Self) -> Self {
14748 Self(self.0 | rhs.0)
14749 }
14750}
14751
14752impl std::ops::BitAnd for TensorUsageFlagBitsARM {
14753 type Output = Self;
14754 fn bitand(self, rhs: Self) -> Self {
14755 Self(self.0 & rhs.0)
14756 }
14757}
14758
14759impl std::ops::BitXor for TensorUsageFlagBitsARM {
14760 type Output = Self;
14761 fn bitxor(self, rhs: Self) -> Self {
14762 Self(self.0 ^ rhs.0)
14763 }
14764}
14765
14766impl std::ops::Not for TensorUsageFlagBitsARM {
14767 type Output = Self;
14768 fn not(self) -> Self {
14769 Self(!self.0)
14770 }
14771}
14772
14773#[repr(transparent)]
14774#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14775pub struct TensorTilingARM(pub i32);
14776impl TensorTilingARM {
14777 pub const fn from_raw(value: i32) -> Self {
14778 Self(value)
14779 }
14780
14781 pub const fn as_raw(self) -> i32 {
14782 self.0
14783 }
14784
14785 pub const fn empty() -> Self {
14786 Self(0)
14787 }
14788
14789 pub const OPTIMAL_ARM: Self = Self(0);
14790 pub const LINEAR_ARM: Self = Self(1);
14791 pub const BRICK_16_WIDE_ARM: Self = Self(1000565000);
14792 pub const BRICK_8_WIDE_ARM: Self = Self(1000565001);
14793 pub const BRICK_4_WIDE_ARM: Self = Self(1000565002);
14794 pub const BLOCK_U_INTERLEAVED_ARM: Self = Self(1000565003);
14795 pub const BLOCK_U_INTERLEAVED_64K_ARM: Self = Self(1000565004);
14796}
14797
14798#[repr(transparent)]
14799#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14800pub struct TensorViewCreateFlagBitsARM(pub u64);
14801impl TensorViewCreateFlagBitsARM {
14802 pub const fn from_raw(value: u64) -> Self {
14803 Self(value)
14804 }
14805
14806 pub const fn as_raw(self) -> u64 {
14807 self.0
14808 }
14809
14810 pub const fn empty() -> Self {
14811 Self(0)
14812 }
14813
14814 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: Self = Self(1);
14815}
14816
14817impl std::ops::BitOr for TensorViewCreateFlagBitsARM {
14818 type Output = Self;
14819 fn bitor(self, rhs: Self) -> Self {
14820 Self(self.0 | rhs.0)
14821 }
14822}
14823
14824impl std::ops::BitAnd for TensorViewCreateFlagBitsARM {
14825 type Output = Self;
14826 fn bitand(self, rhs: Self) -> Self {
14827 Self(self.0 & rhs.0)
14828 }
14829}
14830
14831impl std::ops::BitXor for TensorViewCreateFlagBitsARM {
14832 type Output = Self;
14833 fn bitxor(self, rhs: Self) -> Self {
14834 Self(self.0 ^ rhs.0)
14835 }
14836}
14837
14838impl std::ops::Not for TensorViewCreateFlagBitsARM {
14839 type Output = Self;
14840 fn not(self) -> Self {
14841 Self(!self.0)
14842 }
14843}
14844
14845#[repr(transparent)]
14846#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14847pub struct DefaultVertexAttributeValueKHR(pub i32);
14848impl DefaultVertexAttributeValueKHR {
14849 pub const fn from_raw(value: i32) -> Self {
14850 Self(value)
14851 }
14852
14853 pub const fn as_raw(self) -> i32 {
14854 self.0
14855 }
14856
14857 pub const fn empty() -> Self {
14858 Self(0)
14859 }
14860
14861 pub const ZERO_ZERO_ZERO_ZERO_KHR: Self = Self(0);
14862 pub const ZERO_ZERO_ZERO_ONE_KHR: Self = Self(1);
14863}
14864
14865#[repr(transparent)]
14866#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14867pub struct DataGraphPipelineSessionCreateFlagBitsARM(pub u64);
14868impl DataGraphPipelineSessionCreateFlagBitsARM {
14869 pub const fn from_raw(value: u64) -> Self {
14870 Self(value)
14871 }
14872
14873 pub const fn as_raw(self) -> u64 {
14874 self.0
14875 }
14876
14877 pub const fn empty() -> Self {
14878 Self(0)
14879 }
14880
14881 pub const PROTECTED_BIT_ARM: Self = Self(1);
14882 pub const OPTICAL_FLOW_CACHE_BIT_ARM: Self = Self(2);
14883}
14884
14885impl std::ops::BitOr for DataGraphPipelineSessionCreateFlagBitsARM {
14886 type Output = Self;
14887 fn bitor(self, rhs: Self) -> Self {
14888 Self(self.0 | rhs.0)
14889 }
14890}
14891
14892impl std::ops::BitAnd for DataGraphPipelineSessionCreateFlagBitsARM {
14893 type Output = Self;
14894 fn bitand(self, rhs: Self) -> Self {
14895 Self(self.0 & rhs.0)
14896 }
14897}
14898
14899impl std::ops::BitXor for DataGraphPipelineSessionCreateFlagBitsARM {
14900 type Output = Self;
14901 fn bitxor(self, rhs: Self) -> Self {
14902 Self(self.0 ^ rhs.0)
14903 }
14904}
14905
14906impl std::ops::Not for DataGraphPipelineSessionCreateFlagBitsARM {
14907 type Output = Self;
14908 fn not(self) -> Self {
14909 Self(!self.0)
14910 }
14911}
14912
14913#[repr(transparent)]
14914#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14915pub struct DataGraphPipelineSessionBindPointARM(pub i32);
14916impl DataGraphPipelineSessionBindPointARM {
14917 pub const fn from_raw(value: i32) -> Self {
14918 Self(value)
14919 }
14920
14921 pub const fn as_raw(self) -> i32 {
14922 self.0
14923 }
14924
14925 pub const fn empty() -> Self {
14926 Self(0)
14927 }
14928
14929 pub const TRANSIENT_ARM: Self = Self(0);
14930 pub const OPTICAL_FLOW_CACHE_ARM: Self = Self(1000631001);
14931 pub const NEURAL_ACCELERATOR_STATISTICS_ARM: Self = Self(1000676000);
14932}
14933
14934#[repr(transparent)]
14935#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14936pub struct DataGraphPipelineSessionBindPointTypeARM(pub i32);
14937impl DataGraphPipelineSessionBindPointTypeARM {
14938 pub const fn from_raw(value: i32) -> Self {
14939 Self(value)
14940 }
14941
14942 pub const fn as_raw(self) -> i32 {
14943 self.0
14944 }
14945
14946 pub const fn empty() -> Self {
14947 Self(0)
14948 }
14949
14950 pub const MEMORY_ARM: Self = Self(0);
14951}
14952
14953#[repr(transparent)]
14954#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14955pub struct DataGraphPipelinePropertyARM(pub i32);
14956impl DataGraphPipelinePropertyARM {
14957 pub const fn from_raw(value: i32) -> Self {
14958 Self(value)
14959 }
14960
14961 pub const fn as_raw(self) -> i32 {
14962 self.0
14963 }
14964
14965 pub const fn empty() -> Self {
14966 Self(0)
14967 }
14968
14969 pub const CREATION_LOG_ARM: Self = Self(0);
14970 pub const IDENTIFIER_ARM: Self = Self(1);
14971 pub const NEURAL_ACCELERATOR_DEBUG_DATABASE_ARM: Self = Self(1000676000);
14972 pub const NEURAL_ACCELERATOR_STATISTICS_INFO_ARM: Self = Self(1000676001);
14973}
14974
14975#[repr(transparent)]
14976#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
14977pub struct DataGraphPipelineDispatchFlagBitsARM(pub u64);
14978impl DataGraphPipelineDispatchFlagBitsARM {
14979 pub const fn from_raw(value: u64) -> Self {
14980 Self(value)
14981 }
14982
14983 pub const fn as_raw(self) -> u64 {
14984 self.0
14985 }
14986
14987 pub const fn empty() -> Self {
14988 Self(0)
14989 }
14990}
14991
14992impl std::ops::BitOr for DataGraphPipelineDispatchFlagBitsARM {
14993 type Output = Self;
14994 fn bitor(self, rhs: Self) -> Self {
14995 Self(self.0 | rhs.0)
14996 }
14997}
14998
14999impl std::ops::BitAnd for DataGraphPipelineDispatchFlagBitsARM {
15000 type Output = Self;
15001 fn bitand(self, rhs: Self) -> Self {
15002 Self(self.0 & rhs.0)
15003 }
15004}
15005
15006impl std::ops::BitXor for DataGraphPipelineDispatchFlagBitsARM {
15007 type Output = Self;
15008 fn bitxor(self, rhs: Self) -> Self {
15009 Self(self.0 ^ rhs.0)
15010 }
15011}
15012
15013impl std::ops::Not for DataGraphPipelineDispatchFlagBitsARM {
15014 type Output = Self;
15015 fn not(self) -> Self {
15016 Self(!self.0)
15017 }
15018}
15019
15020#[repr(transparent)]
15021#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15022pub struct PhysicalDeviceDataGraphProcessingEngineTypeARM(pub i32);
15023impl PhysicalDeviceDataGraphProcessingEngineTypeARM {
15024 pub const fn from_raw(value: i32) -> Self {
15025 Self(value)
15026 }
15027
15028 pub const fn as_raw(self) -> i32 {
15029 self.0
15030 }
15031
15032 pub const fn empty() -> Self {
15033 Self(0)
15034 }
15035
15036 pub const DEFAULT_ARM: Self = Self(0);
15037 pub const NEURAL_QCOM: Self = Self(1000629000);
15038 pub const COMPUTE_QCOM: Self = Self(1000629001);
15039}
15040
15041#[repr(transparent)]
15042#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15043pub struct PhysicalDeviceDataGraphOperationTypeARM(pub i32);
15044impl PhysicalDeviceDataGraphOperationTypeARM {
15045 pub const fn from_raw(value: i32) -> Self {
15046 Self(value)
15047 }
15048
15049 pub const fn as_raw(self) -> i32 {
15050 self.0
15051 }
15052
15053 pub const fn empty() -> Self {
15054 Self(0)
15055 }
15056
15057 pub const SPIRV_EXTENDED_INSTRUCTION_SET_ARM: Self = Self(0);
15058 pub const NEURAL_MODEL_QCOM: Self = Self(1000629000);
15059 pub const BUILTIN_MODEL_QCOM: Self = Self(1000629001);
15060 pub const OPTICAL_FLOW_ARM: Self = Self(1000631000);
15061}
15062
15063#[repr(transparent)]
15064#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15065pub struct DataGraphModelCacheTypeQCOM(pub i32);
15066impl DataGraphModelCacheTypeQCOM {
15067 pub const fn from_raw(value: i32) -> Self {
15068 Self(value)
15069 }
15070
15071 pub const fn as_raw(self) -> i32 {
15072 self.0
15073 }
15074
15075 pub const fn empty() -> Self {
15076 Self(0)
15077 }
15078
15079 pub const GENERIC_BINARY_QCOM: Self = Self(0);
15080}
15081
15082#[repr(transparent)]
15083#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15084pub struct PerfHintTypeQCOM(pub i32);
15085impl PerfHintTypeQCOM {
15086 pub const fn from_raw(value: i32) -> Self {
15087 Self(value)
15088 }
15089
15090 pub const fn as_raw(self) -> i32 {
15091 self.0
15092 }
15093
15094 pub const fn empty() -> Self {
15095 Self(0)
15096 }
15097
15098 pub const DEFAULT_QCOM: Self = Self(0);
15099 pub const FREQUENCY_MIN_QCOM: Self = Self(1);
15100 pub const FREQUENCY_MAX_QCOM: Self = Self(2);
15101 pub const FREQUENCY_SCALED_QCOM: Self = Self(3);
15102}
15103
15104#[repr(transparent)]
15105#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15106pub struct ThrottleHintTypeSEC(pub i32);
15107impl ThrottleHintTypeSEC {
15108 pub const fn from_raw(value: i32) -> Self {
15109 Self(value)
15110 }
15111
15112 pub const fn as_raw(self) -> i32 {
15113 self.0
15114 }
15115
15116 pub const fn empty() -> Self {
15117 Self(0)
15118 }
15119
15120 pub const THROTTLE_HINT_TYPE_DEFAULT_SEC: Self = Self(0);
15121 pub const THROTTLE_HINT_TYPE_LOW_SEC: Self = Self(1);
15122 pub const THROTTLE_HINT_TYPE_HIGH_SEC: Self = Self(2);
15123}
15124
15125#[repr(transparent)]
15126#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15127pub struct VideoEncodeRgbModelConversionFlagBitsVALVE(pub u32);
15128impl VideoEncodeRgbModelConversionFlagBitsVALVE {
15129 pub const fn from_raw(value: u32) -> Self {
15130 Self(value)
15131 }
15132
15133 pub const fn as_raw(self) -> u32 {
15134 self.0
15135 }
15136
15137 pub const fn empty() -> Self {
15138 Self(0)
15139 }
15140
15141 pub const RGB_IDENTITY_BIT_VALVE: Self = Self(1);
15142 pub const YCBCR_IDENTITY_BIT_VALVE: Self = Self(2);
15143 pub const YCBCR_709_BIT_VALVE: Self = Self(4);
15144 pub const YCBCR_601_BIT_VALVE: Self = Self(8);
15145 pub const YCBCR_2020_BIT_VALVE: Self = Self(16);
15146}
15147
15148impl std::ops::BitOr for VideoEncodeRgbModelConversionFlagBitsVALVE {
15149 type Output = Self;
15150 fn bitor(self, rhs: Self) -> Self {
15151 Self(self.0 | rhs.0)
15152 }
15153}
15154
15155impl std::ops::BitAnd for VideoEncodeRgbModelConversionFlagBitsVALVE {
15156 type Output = Self;
15157 fn bitand(self, rhs: Self) -> Self {
15158 Self(self.0 & rhs.0)
15159 }
15160}
15161
15162impl std::ops::BitXor for VideoEncodeRgbModelConversionFlagBitsVALVE {
15163 type Output = Self;
15164 fn bitxor(self, rhs: Self) -> Self {
15165 Self(self.0 ^ rhs.0)
15166 }
15167}
15168
15169impl std::ops::Not for VideoEncodeRgbModelConversionFlagBitsVALVE {
15170 type Output = Self;
15171 fn not(self) -> Self {
15172 Self(!self.0)
15173 }
15174}
15175
15176#[repr(transparent)]
15177#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15178pub struct VideoEncodeRgbRangeCompressionFlagBitsVALVE(pub u32);
15179impl VideoEncodeRgbRangeCompressionFlagBitsVALVE {
15180 pub const fn from_raw(value: u32) -> Self {
15181 Self(value)
15182 }
15183
15184 pub const fn as_raw(self) -> u32 {
15185 self.0
15186 }
15187
15188 pub const fn empty() -> Self {
15189 Self(0)
15190 }
15191
15192 pub const FULL_RANGE_BIT_VALVE: Self = Self(1);
15193 pub const NARROW_RANGE_BIT_VALVE: Self = Self(2);
15194}
15195
15196impl std::ops::BitOr for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
15197 type Output = Self;
15198 fn bitor(self, rhs: Self) -> Self {
15199 Self(self.0 | rhs.0)
15200 }
15201}
15202
15203impl std::ops::BitAnd for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
15204 type Output = Self;
15205 fn bitand(self, rhs: Self) -> Self {
15206 Self(self.0 & rhs.0)
15207 }
15208}
15209
15210impl std::ops::BitXor for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
15211 type Output = Self;
15212 fn bitxor(self, rhs: Self) -> Self {
15213 Self(self.0 ^ rhs.0)
15214 }
15215}
15216
15217impl std::ops::Not for VideoEncodeRgbRangeCompressionFlagBitsVALVE {
15218 type Output = Self;
15219 fn not(self) -> Self {
15220 Self(!self.0)
15221 }
15222}
15223
15224#[repr(transparent)]
15225#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15226pub struct VideoEncodeRgbChromaOffsetFlagBitsVALVE(pub u32);
15227impl VideoEncodeRgbChromaOffsetFlagBitsVALVE {
15228 pub const fn from_raw(value: u32) -> Self {
15229 Self(value)
15230 }
15231
15232 pub const fn as_raw(self) -> u32 {
15233 self.0
15234 }
15235
15236 pub const fn empty() -> Self {
15237 Self(0)
15238 }
15239
15240 pub const COSITED_EVEN_BIT_VALVE: Self = Self(1);
15241 pub const MIDPOINT_BIT_VALVE: Self = Self(2);
15242}
15243
15244impl std::ops::BitOr for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
15245 type Output = Self;
15246 fn bitor(self, rhs: Self) -> Self {
15247 Self(self.0 | rhs.0)
15248 }
15249}
15250
15251impl std::ops::BitAnd for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
15252 type Output = Self;
15253 fn bitand(self, rhs: Self) -> Self {
15254 Self(self.0 & rhs.0)
15255 }
15256}
15257
15258impl std::ops::BitXor for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
15259 type Output = Self;
15260 fn bitxor(self, rhs: Self) -> Self {
15261 Self(self.0 ^ rhs.0)
15262 }
15263}
15264
15265impl std::ops::Not for VideoEncodeRgbChromaOffsetFlagBitsVALVE {
15266 type Output = Self;
15267 fn not(self) -> Self {
15268 Self(!self.0)
15269 }
15270}
15271
15272#[repr(transparent)]
15273#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15274pub struct DescriptorMappingSourceEXT(pub i32);
15275impl DescriptorMappingSourceEXT {
15276 pub const fn from_raw(value: i32) -> Self {
15277 Self(value)
15278 }
15279
15280 pub const fn as_raw(self) -> i32 {
15281 self.0
15282 }
15283
15284 pub const fn empty() -> Self {
15285 Self(0)
15286 }
15287
15288 pub const HEAP_WITH_CONSTANT_OFFSET_EXT: Self = Self(0);
15289 pub const HEAP_WITH_PUSH_INDEX_EXT: Self = Self(1);
15290 pub const HEAP_WITH_INDIRECT_INDEX_EXT: Self = Self(2);
15291 pub const HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT: Self = Self(3);
15292 pub const RESOURCE_HEAP_DATA_EXT: Self = Self(4);
15293 pub const PUSH_DATA_EXT: Self = Self(5);
15294 pub const PUSH_ADDRESS_EXT: Self = Self(6);
15295 pub const INDIRECT_ADDRESS_EXT: Self = Self(7);
15296 pub const HEAP_WITH_SHADER_RECORD_INDEX_EXT: Self = Self(8);
15297 pub const SHADER_RECORD_DATA_EXT: Self = Self(9);
15298 pub const SHADER_RECORD_ADDRESS_EXT: Self = Self(10);
15299}
15300
15301#[repr(transparent)]
15302#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15303pub struct SpirvResourceTypeFlagBitsEXT(pub u32);
15304impl SpirvResourceTypeFlagBitsEXT {
15305 pub const fn from_raw(value: u32) -> Self {
15306 Self(value)
15307 }
15308
15309 pub const fn as_raw(self) -> u32 {
15310 self.0
15311 }
15312
15313 pub const fn empty() -> Self {
15314 Self(0)
15315 }
15316
15317 pub const ALL_EXT: Self = Self(2147483647);
15318 pub const SAMPLER_BIT_EXT: Self = Self(1);
15319 pub const SAMPLED_IMAGE_BIT_EXT: Self = Self(2);
15320 pub const READ_ONLY_IMAGE_BIT_EXT: Self = Self(4);
15321 pub const READ_WRITE_IMAGE_BIT_EXT: Self = Self(8);
15322 pub const COMBINED_SAMPLED_IMAGE_BIT_EXT: Self = Self(16);
15323 pub const UNIFORM_BUFFER_BIT_EXT: Self = Self(32);
15324 pub const READ_ONLY_STORAGE_BUFFER_BIT_EXT: Self = Self(64);
15325 pub const READ_WRITE_STORAGE_BUFFER_BIT_EXT: Self = Self(128);
15326 pub const ACCELERATION_STRUCTURE_BIT_EXT: Self = Self(256);
15327 pub const TENSOR_BIT_ARM: Self = Self(512);
15328}
15329
15330impl std::ops::BitOr for SpirvResourceTypeFlagBitsEXT {
15331 type Output = Self;
15332 fn bitor(self, rhs: Self) -> Self {
15333 Self(self.0 | rhs.0)
15334 }
15335}
15336
15337impl std::ops::BitAnd for SpirvResourceTypeFlagBitsEXT {
15338 type Output = Self;
15339 fn bitand(self, rhs: Self) -> Self {
15340 Self(self.0 & rhs.0)
15341 }
15342}
15343
15344impl std::ops::BitXor for SpirvResourceTypeFlagBitsEXT {
15345 type Output = Self;
15346 fn bitxor(self, rhs: Self) -> Self {
15347 Self(self.0 ^ rhs.0)
15348 }
15349}
15350
15351impl std::ops::Not for SpirvResourceTypeFlagBitsEXT {
15352 type Output = Self;
15353 fn not(self) -> Self {
15354 Self(!self.0)
15355 }
15356}
15357
15358#[repr(transparent)]
15359#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15360pub struct GpaSqShaderStageFlagBitsAMD(pub u32);
15361impl GpaSqShaderStageFlagBitsAMD {
15362 pub const fn from_raw(value: u32) -> Self {
15363 Self(value)
15364 }
15365
15366 pub const fn as_raw(self) -> u32 {
15367 self.0
15368 }
15369
15370 pub const fn empty() -> Self {
15371 Self(0)
15372 }
15373
15374 pub const PS_BIT_AMD: Self = Self(1);
15375 pub const VS_BIT_AMD: Self = Self(2);
15376 pub const GS_BIT_AMD: Self = Self(4);
15377 pub const ES_BIT_AMD: Self = Self(8);
15378 pub const HS_BIT_AMD: Self = Self(16);
15379 pub const LS_BIT_AMD: Self = Self(32);
15380 pub const CS_BIT_AMD: Self = Self(64);
15381}
15382
15383impl std::ops::BitOr for GpaSqShaderStageFlagBitsAMD {
15384 type Output = Self;
15385 fn bitor(self, rhs: Self) -> Self {
15386 Self(self.0 | rhs.0)
15387 }
15388}
15389
15390impl std::ops::BitAnd for GpaSqShaderStageFlagBitsAMD {
15391 type Output = Self;
15392 fn bitand(self, rhs: Self) -> Self {
15393 Self(self.0 & rhs.0)
15394 }
15395}
15396
15397impl std::ops::BitXor for GpaSqShaderStageFlagBitsAMD {
15398 type Output = Self;
15399 fn bitxor(self, rhs: Self) -> Self {
15400 Self(self.0 ^ rhs.0)
15401 }
15402}
15403
15404impl std::ops::Not for GpaSqShaderStageFlagBitsAMD {
15405 type Output = Self;
15406 fn not(self) -> Self {
15407 Self(!self.0)
15408 }
15409}
15410
15411#[repr(transparent)]
15412#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15413pub struct GpaPerfBlockAMD(pub i32);
15414impl GpaPerfBlockAMD {
15415 pub const fn from_raw(value: i32) -> Self {
15416 Self(value)
15417 }
15418
15419 pub const fn as_raw(self) -> i32 {
15420 self.0
15421 }
15422
15423 pub const fn empty() -> Self {
15424 Self(0)
15425 }
15426
15427 pub const CPF_AMD: Self = Self(0);
15428 pub const IA_AMD: Self = Self(1);
15429 pub const VGT_AMD: Self = Self(2);
15430 pub const PA_AMD: Self = Self(3);
15431 pub const SC_AMD: Self = Self(4);
15432 pub const SPI_AMD: Self = Self(5);
15433 pub const SQ_AMD: Self = Self(6);
15434 pub const SX_AMD: Self = Self(7);
15435 pub const TA_AMD: Self = Self(8);
15436 pub const TD_AMD: Self = Self(9);
15437 pub const TCP_AMD: Self = Self(10);
15438 pub const TCC_AMD: Self = Self(11);
15439 pub const TCA_AMD: Self = Self(12);
15440 pub const DB_AMD: Self = Self(13);
15441 pub const CB_AMD: Self = Self(14);
15442 pub const GDS_AMD: Self = Self(15);
15443 pub const SRBM_AMD: Self = Self(16);
15444 pub const GRBM_AMD: Self = Self(17);
15445 pub const GRBM_SE_AMD: Self = Self(18);
15446 pub const RLC_AMD: Self = Self(19);
15447 pub const DMA_AMD: Self = Self(20);
15448 pub const MC_AMD: Self = Self(21);
15449 pub const CPG_AMD: Self = Self(22);
15450 pub const CPC_AMD: Self = Self(23);
15451 pub const WD_AMD: Self = Self(24);
15452 pub const TCS_AMD: Self = Self(25);
15453 pub const ATC_AMD: Self = Self(26);
15454 pub const ATC_L2_AMD: Self = Self(27);
15455 pub const MC_VM_L2_AMD: Self = Self(28);
15456 pub const EA_AMD: Self = Self(29);
15457 pub const RPB_AMD: Self = Self(30);
15458 pub const RMI_AMD: Self = Self(31);
15459 pub const UMCCH_AMD: Self = Self(32);
15460 pub const GE_AMD: Self = Self(33);
15461 pub const GL1A_AMD: Self = Self(34);
15462 pub const GL1C_AMD: Self = Self(35);
15463 pub const GL1CG_AMD: Self = Self(36);
15464 pub const GL2A_AMD: Self = Self(37);
15465 pub const GL2C_AMD: Self = Self(38);
15466 pub const CHA_AMD: Self = Self(39);
15467 pub const CHC_AMD: Self = Self(40);
15468 pub const CHCG_AMD: Self = Self(41);
15469 pub const GUS_AMD: Self = Self(42);
15470 pub const GCR_AMD: Self = Self(43);
15471 pub const PH_AMD: Self = Self(44);
15472 pub const UTCL1_AMD: Self = Self(45);
15473 pub const GE1_AMD: Self = Self(33);
15474 pub const GE_DIST_AMD: Self = Self(46);
15475 pub const GE_SE_AMD: Self = Self(47);
15476 pub const DF_MALL_AMD: Self = Self(48);
15477 pub const SQ_WGP_AMD: Self = Self(49);
15478 pub const PC_AMD: Self = Self(50);
15479 pub const GL1XA_AMD: Self = Self(51);
15480 pub const GL1XC_AMD: Self = Self(52);
15481 pub const WGS_AMD: Self = Self(53);
15482 pub const EACPWD_AMD: Self = Self(54);
15483 pub const EASE_AMD: Self = Self(55);
15484 pub const RLCUSER_AMD: Self = Self(56);
15485 pub const RLCLOCAL_AMD: Self = Self(56);
15486}
15487
15488#[repr(transparent)]
15489#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15490pub struct GpaSampleTypeAMD(pub i32);
15491impl GpaSampleTypeAMD {
15492 pub const fn from_raw(value: i32) -> Self {
15493 Self(value)
15494 }
15495
15496 pub const fn as_raw(self) -> i32 {
15497 self.0
15498 }
15499
15500 pub const fn empty() -> Self {
15501 Self(0)
15502 }
15503
15504 pub const CUMULATIVE_AMD: Self = Self(0);
15505 pub const TRACE_AMD: Self = Self(1);
15506 pub const TIMING_AMD: Self = Self(2);
15507}
15508
15509#[repr(transparent)]
15510#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15511pub struct GpaDeviceClockModeAMD(pub i32);
15512impl GpaDeviceClockModeAMD {
15513 pub const fn from_raw(value: i32) -> Self {
15514 Self(value)
15515 }
15516
15517 pub const fn as_raw(self) -> i32 {
15518 self.0
15519 }
15520
15521 pub const fn empty() -> Self {
15522 Self(0)
15523 }
15524
15525 pub const DEFAULT_AMD: Self = Self(0);
15526 pub const QUERY_AMD: Self = Self(1);
15527 pub const PROFILING_AMD: Self = Self(2);
15528 pub const MIN_MEMORY_AMD: Self = Self(3);
15529 pub const MIN_ENGINE_AMD: Self = Self(4);
15530 pub const PEAK_AMD: Self = Self(5);
15531}
15532
15533#[repr(transparent)]
15534#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15535pub struct AddressCommandFlagBitsKHR(pub u32);
15536impl AddressCommandFlagBitsKHR {
15537 pub const fn from_raw(value: u32) -> Self {
15538 Self(value)
15539 }
15540
15541 pub const fn as_raw(self) -> u32 {
15542 self.0
15543 }
15544
15545 pub const fn empty() -> Self {
15546 Self(0)
15547 }
15548
15549 pub const PROTECTED_BIT_KHR: Self = Self(1);
15550 pub const FULLY_BOUND_BIT_KHR: Self = Self(2);
15551 pub const STORAGE_BUFFER_USAGE_BIT_KHR: Self = Self(4);
15552 pub const UNKNOWN_STORAGE_BUFFER_USAGE_BIT_KHR: Self = Self(8);
15553 pub const TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR: Self = Self(16);
15554 pub const UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR: Self = Self(32);
15555}
15556
15557impl std::ops::BitOr for AddressCommandFlagBitsKHR {
15558 type Output = Self;
15559 fn bitor(self, rhs: Self) -> Self {
15560 Self(self.0 | rhs.0)
15561 }
15562}
15563
15564impl std::ops::BitAnd for AddressCommandFlagBitsKHR {
15565 type Output = Self;
15566 fn bitand(self, rhs: Self) -> Self {
15567 Self(self.0 & rhs.0)
15568 }
15569}
15570
15571impl std::ops::BitXor for AddressCommandFlagBitsKHR {
15572 type Output = Self;
15573 fn bitxor(self, rhs: Self) -> Self {
15574 Self(self.0 ^ rhs.0)
15575 }
15576}
15577
15578impl std::ops::Not for AddressCommandFlagBitsKHR {
15579 type Output = Self;
15580 fn not(self) -> Self {
15581 Self(!self.0)
15582 }
15583}
15584
15585#[repr(transparent)]
15586#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15587pub struct DataGraphTOSAQualityFlagBitsARM(pub u32);
15588impl DataGraphTOSAQualityFlagBitsARM {
15589 pub const fn from_raw(value: u32) -> Self {
15590 Self(value)
15591 }
15592
15593 pub const fn as_raw(self) -> u32 {
15594 self.0
15595 }
15596
15597 pub const fn empty() -> Self {
15598 Self(0)
15599 }
15600
15601 pub const DATA_GRAPH_TOSA_QUALITY_ACCELERATED_ARM: Self = Self(1);
15602 pub const DATA_GRAPH_TOSA_QUALITY_CONFORMANT_ARM: Self = Self(2);
15603 pub const DATA_GRAPH_TOSA_QUALITY_EXPERIMENTAL_ARM: Self = Self(4);
15604 pub const DATA_GRAPH_TOSA_QUALITY_DEPRECATED_ARM: Self = Self(8);
15605}
15606
15607impl std::ops::BitOr for DataGraphTOSAQualityFlagBitsARM {
15608 type Output = Self;
15609 fn bitor(self, rhs: Self) -> Self {
15610 Self(self.0 | rhs.0)
15611 }
15612}
15613
15614impl std::ops::BitAnd for DataGraphTOSAQualityFlagBitsARM {
15615 type Output = Self;
15616 fn bitand(self, rhs: Self) -> Self {
15617 Self(self.0 & rhs.0)
15618 }
15619}
15620
15621impl std::ops::BitXor for DataGraphTOSAQualityFlagBitsARM {
15622 type Output = Self;
15623 fn bitxor(self, rhs: Self) -> Self {
15624 Self(self.0 ^ rhs.0)
15625 }
15626}
15627
15628impl std::ops::Not for DataGraphTOSAQualityFlagBitsARM {
15629 type Output = Self;
15630 fn not(self) -> Self {
15631 Self(!self.0)
15632 }
15633}
15634
15635#[repr(transparent)]
15636#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15637pub struct DataGraphTOSALevelARM(pub i32);
15638impl DataGraphTOSALevelARM {
15639 pub const fn from_raw(value: i32) -> Self {
15640 Self(value)
15641 }
15642
15643 pub const fn as_raw(self) -> i32 {
15644 self.0
15645 }
15646
15647 pub const fn empty() -> Self {
15648 Self(0)
15649 }
15650
15651 pub const DATA_GRAPH_TOSA_LEVEL_NONE_ARM: Self = Self(0);
15652 pub const DATA_GRAPH_TOSA_LEVEL_8K_ARM: Self = Self(1);
15653}
15654
15655#[repr(transparent)]
15656#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15657pub struct DataGraphOpticalFlowGridSizeFlagBitsARM(pub u32);
15658impl DataGraphOpticalFlowGridSizeFlagBitsARM {
15659 pub const fn from_raw(value: u32) -> Self {
15660 Self(value)
15661 }
15662
15663 pub const fn as_raw(self) -> u32 {
15664 self.0
15665 }
15666
15667 pub const fn empty() -> Self {
15668 Self(0)
15669 }
15670
15671 pub const UNKNOWN_ARM: Self = Self(0);
15672 pub const _1X1_BIT_ARM: Self = Self(1);
15673 pub const _2X2_BIT_ARM: Self = Self(2);
15674 pub const _4X4_BIT_ARM: Self = Self(4);
15675 pub const _8X8_BIT_ARM: Self = Self(8);
15676}
15677
15678impl std::ops::BitOr for DataGraphOpticalFlowGridSizeFlagBitsARM {
15679 type Output = Self;
15680 fn bitor(self, rhs: Self) -> Self {
15681 Self(self.0 | rhs.0)
15682 }
15683}
15684
15685impl std::ops::BitAnd for DataGraphOpticalFlowGridSizeFlagBitsARM {
15686 type Output = Self;
15687 fn bitand(self, rhs: Self) -> Self {
15688 Self(self.0 & rhs.0)
15689 }
15690}
15691
15692impl std::ops::BitXor for DataGraphOpticalFlowGridSizeFlagBitsARM {
15693 type Output = Self;
15694 fn bitxor(self, rhs: Self) -> Self {
15695 Self(self.0 ^ rhs.0)
15696 }
15697}
15698
15699impl std::ops::Not for DataGraphOpticalFlowGridSizeFlagBitsARM {
15700 type Output = Self;
15701 fn not(self) -> Self {
15702 Self(!self.0)
15703 }
15704}
15705
15706#[repr(transparent)]
15707#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15708pub struct DataGraphOpticalFlowImageUsageFlagBitsARM(pub u32);
15709impl DataGraphOpticalFlowImageUsageFlagBitsARM {
15710 pub const fn from_raw(value: u32) -> Self {
15711 Self(value)
15712 }
15713
15714 pub const fn as_raw(self) -> u32 {
15715 self.0
15716 }
15717
15718 pub const fn empty() -> Self {
15719 Self(0)
15720 }
15721
15722 pub const UNKNOWN_ARM: Self = Self(0);
15723 pub const INPUT_BIT_ARM: Self = Self(1);
15724 pub const OUTPUT_BIT_ARM: Self = Self(2);
15725 pub const HINT_BIT_ARM: Self = Self(4);
15726 pub const COST_BIT_ARM: Self = Self(8);
15727}
15728
15729impl std::ops::BitOr for DataGraphOpticalFlowImageUsageFlagBitsARM {
15730 type Output = Self;
15731 fn bitor(self, rhs: Self) -> Self {
15732 Self(self.0 | rhs.0)
15733 }
15734}
15735
15736impl std::ops::BitAnd for DataGraphOpticalFlowImageUsageFlagBitsARM {
15737 type Output = Self;
15738 fn bitand(self, rhs: Self) -> Self {
15739 Self(self.0 & rhs.0)
15740 }
15741}
15742
15743impl std::ops::BitXor for DataGraphOpticalFlowImageUsageFlagBitsARM {
15744 type Output = Self;
15745 fn bitxor(self, rhs: Self) -> Self {
15746 Self(self.0 ^ rhs.0)
15747 }
15748}
15749
15750impl std::ops::Not for DataGraphOpticalFlowImageUsageFlagBitsARM {
15751 type Output = Self;
15752 fn not(self) -> Self {
15753 Self(!self.0)
15754 }
15755}
15756
15757#[repr(transparent)]
15758#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15759pub struct DataGraphOpticalFlowPerformanceLevelARM(pub i32);
15760impl DataGraphOpticalFlowPerformanceLevelARM {
15761 pub const fn from_raw(value: i32) -> Self {
15762 Self(value)
15763 }
15764
15765 pub const fn as_raw(self) -> i32 {
15766 self.0
15767 }
15768
15769 pub const fn empty() -> Self {
15770 Self(0)
15771 }
15772
15773 pub const UNKNOWN_ARM: Self = Self(0);
15774 pub const SLOW_ARM: Self = Self(1);
15775 pub const MEDIUM_ARM: Self = Self(2);
15776 pub const FAST_ARM: Self = Self(3);
15777}
15778
15779#[repr(transparent)]
15780#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15781pub struct DataGraphPipelineNodeConnectionTypeARM(pub i32);
15782impl DataGraphPipelineNodeConnectionTypeARM {
15783 pub const fn from_raw(value: i32) -> Self {
15784 Self(value)
15785 }
15786
15787 pub const fn as_raw(self) -> i32 {
15788 self.0
15789 }
15790
15791 pub const fn empty() -> Self {
15792 Self(0)
15793 }
15794
15795 pub const OPTICAL_FLOW_INPUT_ARM: Self = Self(1000631000);
15796 pub const OPTICAL_FLOW_REFERENCE_ARM: Self = Self(1000631001);
15797 pub const OPTICAL_FLOW_HINT_ARM: Self = Self(1000631002);
15798 pub const OPTICAL_FLOW_FLOW_VECTOR_ARM: Self = Self(1000631003);
15799 pub const OPTICAL_FLOW_COST_ARM: Self = Self(1000631004);
15800}
15801
15802#[repr(transparent)]
15803#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15804pub struct DataGraphPipelineNodeTypeARM(pub i32);
15805impl DataGraphPipelineNodeTypeARM {
15806 pub const fn from_raw(value: i32) -> Self {
15807 Self(value)
15808 }
15809
15810 pub const fn as_raw(self) -> i32 {
15811 self.0
15812 }
15813
15814 pub const fn empty() -> Self {
15815 Self(0)
15816 }
15817
15818 pub const OPTICAL_FLOW_ARM: Self = Self(1000631000);
15819}
15820
15821#[repr(transparent)]
15822#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15823pub struct DataGraphOpticalFlowCreateFlagBitsARM(pub u32);
15824impl DataGraphOpticalFlowCreateFlagBitsARM {
15825 pub const fn from_raw(value: u32) -> Self {
15826 Self(value)
15827 }
15828
15829 pub const fn as_raw(self) -> u32 {
15830 self.0
15831 }
15832
15833 pub const fn empty() -> Self {
15834 Self(0)
15835 }
15836
15837 pub const ENABLE_HINT_BIT_ARM: Self = Self(1);
15838 pub const ENABLE_COST_BIT_ARM: Self = Self(2);
15839 pub const RESERVED_30_BIT_ARM: Self = Self(1073741824);
15840}
15841
15842impl std::ops::BitOr for DataGraphOpticalFlowCreateFlagBitsARM {
15843 type Output = Self;
15844 fn bitor(self, rhs: Self) -> Self {
15845 Self(self.0 | rhs.0)
15846 }
15847}
15848
15849impl std::ops::BitAnd for DataGraphOpticalFlowCreateFlagBitsARM {
15850 type Output = Self;
15851 fn bitand(self, rhs: Self) -> Self {
15852 Self(self.0 & rhs.0)
15853 }
15854}
15855
15856impl std::ops::BitXor for DataGraphOpticalFlowCreateFlagBitsARM {
15857 type Output = Self;
15858 fn bitxor(self, rhs: Self) -> Self {
15859 Self(self.0 ^ rhs.0)
15860 }
15861}
15862
15863impl std::ops::Not for DataGraphOpticalFlowCreateFlagBitsARM {
15864 type Output = Self;
15865 fn not(self) -> Self {
15866 Self(!self.0)
15867 }
15868}
15869
15870#[repr(transparent)]
15871#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15872pub struct DataGraphOpticalFlowExecuteFlagBitsARM(pub u32);
15873impl DataGraphOpticalFlowExecuteFlagBitsARM {
15874 pub const fn from_raw(value: u32) -> Self {
15875 Self(value)
15876 }
15877
15878 pub const fn as_raw(self) -> u32 {
15879 self.0
15880 }
15881
15882 pub const fn empty() -> Self {
15883 Self(0)
15884 }
15885
15886 pub const DISABLE_TEMPORAL_HINTS_BIT_ARM: Self = Self(1);
15887 pub const INPUT_UNCHANGED_BIT_ARM: Self = Self(2);
15888 pub const REFERENCE_UNCHANGED_BIT_ARM: Self = Self(4);
15889 pub const INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM: Self = Self(8);
15890 pub const REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM: Self = Self(16);
15891}
15892
15893impl std::ops::BitOr for DataGraphOpticalFlowExecuteFlagBitsARM {
15894 type Output = Self;
15895 fn bitor(self, rhs: Self) -> Self {
15896 Self(self.0 | rhs.0)
15897 }
15898}
15899
15900impl std::ops::BitAnd for DataGraphOpticalFlowExecuteFlagBitsARM {
15901 type Output = Self;
15902 fn bitand(self, rhs: Self) -> Self {
15903 Self(self.0 & rhs.0)
15904 }
15905}
15906
15907impl std::ops::BitXor for DataGraphOpticalFlowExecuteFlagBitsARM {
15908 type Output = Self;
15909 fn bitxor(self, rhs: Self) -> Self {
15910 Self(self.0 ^ rhs.0)
15911 }
15912}
15913
15914impl std::ops::Not for DataGraphOpticalFlowExecuteFlagBitsARM {
15915 type Output = Self;
15916 fn not(self) -> Self {
15917 Self(!self.0)
15918 }
15919}
15920
15921#[repr(transparent)]
15922#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15923pub struct NeuralAcceleratorStatisticsModeARM(pub i32);
15924impl NeuralAcceleratorStatisticsModeARM {
15925 pub const fn from_raw(value: i32) -> Self {
15926 Self(value)
15927 }
15928
15929 pub const fn as_raw(self) -> i32 {
15930 self.0
15931 }
15932
15933 pub const fn empty() -> Self {
15934 Self(0)
15935 }
15936
15937 pub const DISABLED_ARM: Self = Self(0);
15938 pub const STATISTICS0_ARM: Self = Self(1);
15939 pub const STATISTICS1_ARM: Self = Self(2);
15940}
15941
15942#[repr(transparent)]
15943#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15944pub struct ImageTilingControlEXT(pub i32);
15945impl ImageTilingControlEXT {
15946 pub const fn from_raw(value: i32) -> Self {
15947 Self(value)
15948 }
15949
15950 pub const fn as_raw(self) -> i32 {
15951 self.0
15952 }
15953
15954 pub const fn empty() -> Self {
15955 Self(0)
15956 }
15957
15958 pub const DEFAULT_EXT: Self = Self(0);
15959 pub const MIN_SIZE_EXT: Self = Self(1);
15960 pub const MAX_PERFORMANCE_EXT: Self = Self(2);
15961}
15962
15963#[repr(transparent)]
15964#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15965pub struct StdVideoH264ChromaFormatIdc(pub i32);
15966impl StdVideoH264ChromaFormatIdc {
15967 pub const fn from_raw(value: i32) -> Self {
15968 Self(value)
15969 }
15970
15971 pub const fn as_raw(self) -> i32 {
15972 self.0
15973 }
15974
15975 pub const fn empty() -> Self {
15976 Self(0)
15977 }
15978
15979 pub const MONOCHROME: Self = Self(0);
15980 pub const _420: Self = Self(1);
15981 pub const _422: Self = Self(2);
15982 pub const _444: Self = Self(3);
15983 pub const INVALID: Self = Self(2147483647);
15984}
15985
15986#[repr(transparent)]
15987#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
15988pub struct StdVideoH264ProfileIdc(pub i32);
15989impl StdVideoH264ProfileIdc {
15990 pub const fn from_raw(value: i32) -> Self {
15991 Self(value)
15992 }
15993
15994 pub const fn as_raw(self) -> i32 {
15995 self.0
15996 }
15997
15998 pub const fn empty() -> Self {
15999 Self(0)
16000 }
16001
16002 pub const BASELINE: Self = Self(66);
16003 pub const MAIN: Self = Self(77);
16004 pub const HIGH: Self = Self(100);
16005 pub const HIGH_10: Self = Self(110);
16006 pub const HIGH_422: Self = Self(122);
16007 pub const HIGH_444_PREDICTIVE: Self = Self(244);
16008 pub const INVALID: Self = Self(2147483647);
16009}
16010
16011#[repr(transparent)]
16012#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16013pub struct StdVideoH264LevelIdc(pub i32);
16014impl StdVideoH264LevelIdc {
16015 pub const fn from_raw(value: i32) -> Self {
16016 Self(value)
16017 }
16018
16019 pub const fn as_raw(self) -> i32 {
16020 self.0
16021 }
16022
16023 pub const fn empty() -> Self {
16024 Self(0)
16025 }
16026
16027 pub const _1_0: Self = Self(0);
16028 pub const _1_1: Self = Self(1);
16029 pub const _1_2: Self = Self(2);
16030 pub const _1_3: Self = Self(3);
16031 pub const _2_0: Self = Self(4);
16032 pub const _2_1: Self = Self(5);
16033 pub const _2_2: Self = Self(6);
16034 pub const _3_0: Self = Self(7);
16035 pub const _3_1: Self = Self(8);
16036 pub const _3_2: Self = Self(9);
16037 pub const _4_0: Self = Self(10);
16038 pub const _4_1: Self = Self(11);
16039 pub const _4_2: Self = Self(12);
16040 pub const _5_0: Self = Self(13);
16041 pub const _5_1: Self = Self(14);
16042 pub const _5_2: Self = Self(15);
16043 pub const _6_0: Self = Self(16);
16044 pub const _6_1: Self = Self(17);
16045 pub const _6_2: Self = Self(18);
16046 pub const INVALID: Self = Self(2147483647);
16047}
16048
16049#[repr(transparent)]
16050#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16051pub struct StdVideoH264PocType(pub i32);
16052impl StdVideoH264PocType {
16053 pub const fn from_raw(value: i32) -> Self {
16054 Self(value)
16055 }
16056
16057 pub const fn as_raw(self) -> i32 {
16058 self.0
16059 }
16060
16061 pub const fn empty() -> Self {
16062 Self(0)
16063 }
16064
16065 pub const _0: Self = Self(0);
16066 pub const _1: Self = Self(1);
16067 pub const _2: Self = Self(2);
16068 pub const INVALID: Self = Self(2147483647);
16069}
16070
16071#[repr(transparent)]
16072#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16073pub struct StdVideoH264AspectRatioIdc(pub i32);
16074impl StdVideoH264AspectRatioIdc {
16075 pub const fn from_raw(value: i32) -> Self {
16076 Self(value)
16077 }
16078
16079 pub const fn as_raw(self) -> i32 {
16080 self.0
16081 }
16082
16083 pub const fn empty() -> Self {
16084 Self(0)
16085 }
16086
16087 pub const UNSPECIFIED: Self = Self(0);
16088 pub const SQUARE: Self = Self(1);
16089 pub const _12_11: Self = Self(2);
16090 pub const _10_11: Self = Self(3);
16091 pub const _16_11: Self = Self(4);
16092 pub const _40_33: Self = Self(5);
16093 pub const _24_11: Self = Self(6);
16094 pub const _20_11: Self = Self(7);
16095 pub const _32_11: Self = Self(8);
16096 pub const _80_33: Self = Self(9);
16097 pub const _18_11: Self = Self(10);
16098 pub const _15_11: Self = Self(11);
16099 pub const _64_33: Self = Self(12);
16100 pub const _160_99: Self = Self(13);
16101 pub const _4_3: Self = Self(14);
16102 pub const _3_2: Self = Self(15);
16103 pub const _2_1: Self = Self(16);
16104 pub const EXTENDED_SAR: Self = Self(255);
16105 pub const INVALID: Self = Self(2147483647);
16106}
16107
16108#[repr(transparent)]
16109#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16110pub struct StdVideoH264WeightedBipredIdc(pub i32);
16111impl StdVideoH264WeightedBipredIdc {
16112 pub const fn from_raw(value: i32) -> Self {
16113 Self(value)
16114 }
16115
16116 pub const fn as_raw(self) -> i32 {
16117 self.0
16118 }
16119
16120 pub const fn empty() -> Self {
16121 Self(0)
16122 }
16123
16124 pub const DEFAULT: Self = Self(0);
16125 pub const EXPLICIT: Self = Self(1);
16126 pub const IMPLICIT: Self = Self(2);
16127 pub const INVALID: Self = Self(2147483647);
16128}
16129
16130#[repr(transparent)]
16131#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16132pub struct StdVideoH264ModificationOfPicNumsIdc(pub i32);
16133impl StdVideoH264ModificationOfPicNumsIdc {
16134 pub const fn from_raw(value: i32) -> Self {
16135 Self(value)
16136 }
16137
16138 pub const fn as_raw(self) -> i32 {
16139 self.0
16140 }
16141
16142 pub const fn empty() -> Self {
16143 Self(0)
16144 }
16145
16146 pub const SHORT_TERM_SUBTRACT: Self = Self(0);
16147 pub const SHORT_TERM_ADD: Self = Self(1);
16148 pub const LONG_TERM: Self = Self(2);
16149 pub const END: Self = Self(3);
16150 pub const INVALID: Self = Self(2147483647);
16151}
16152
16153#[repr(transparent)]
16154#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16155pub struct StdVideoH264MemMgmtControlOp(pub i32);
16156impl StdVideoH264MemMgmtControlOp {
16157 pub const fn from_raw(value: i32) -> Self {
16158 Self(value)
16159 }
16160
16161 pub const fn as_raw(self) -> i32 {
16162 self.0
16163 }
16164
16165 pub const fn empty() -> Self {
16166 Self(0)
16167 }
16168
16169 pub const END: Self = Self(0);
16170 pub const UNMARK_SHORT_TERM: Self = Self(1);
16171 pub const UNMARK_LONG_TERM: Self = Self(2);
16172 pub const MARK_LONG_TERM: Self = Self(3);
16173 pub const SET_MAX_LONG_TERM_INDEX: Self = Self(4);
16174 pub const UNMARK_ALL: Self = Self(5);
16175 pub const MARK_CURRENT_AS_LONG_TERM: Self = Self(6);
16176 pub const INVALID: Self = Self(2147483647);
16177}
16178
16179#[repr(transparent)]
16180#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16181pub struct StdVideoH264CabacInitIdc(pub i32);
16182impl StdVideoH264CabacInitIdc {
16183 pub const fn from_raw(value: i32) -> Self {
16184 Self(value)
16185 }
16186
16187 pub const fn as_raw(self) -> i32 {
16188 self.0
16189 }
16190
16191 pub const fn empty() -> Self {
16192 Self(0)
16193 }
16194
16195 pub const _0: Self = Self(0);
16196 pub const _1: Self = Self(1);
16197 pub const _2: Self = Self(2);
16198 pub const INVALID: Self = Self(2147483647);
16199}
16200
16201#[repr(transparent)]
16202#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16203pub struct StdVideoH264DisableDeblockingFilterIdc(pub i32);
16204impl StdVideoH264DisableDeblockingFilterIdc {
16205 pub const fn from_raw(value: i32) -> Self {
16206 Self(value)
16207 }
16208
16209 pub const fn as_raw(self) -> i32 {
16210 self.0
16211 }
16212
16213 pub const fn empty() -> Self {
16214 Self(0)
16215 }
16216
16217 pub const DISABLED: Self = Self(0);
16218 pub const ENABLED: Self = Self(1);
16219 pub const PARTIAL: Self = Self(2);
16220 pub const INVALID: Self = Self(2147483647);
16221}
16222
16223#[repr(transparent)]
16224#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16225pub struct StdVideoH264SliceType(pub i32);
16226impl StdVideoH264SliceType {
16227 pub const fn from_raw(value: i32) -> Self {
16228 Self(value)
16229 }
16230
16231 pub const fn as_raw(self) -> i32 {
16232 self.0
16233 }
16234
16235 pub const fn empty() -> Self {
16236 Self(0)
16237 }
16238
16239 pub const P: Self = Self(0);
16240 pub const B: Self = Self(1);
16241 pub const I: Self = Self(2);
16242 pub const INVALID: Self = Self(2147483647);
16243}
16244
16245#[repr(transparent)]
16246#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16247pub struct StdVideoH264PictureType(pub i32);
16248impl StdVideoH264PictureType {
16249 pub const fn from_raw(value: i32) -> Self {
16250 Self(value)
16251 }
16252
16253 pub const fn as_raw(self) -> i32 {
16254 self.0
16255 }
16256
16257 pub const fn empty() -> Self {
16258 Self(0)
16259 }
16260
16261 pub const P: Self = Self(0);
16262 pub const B: Self = Self(1);
16263 pub const I: Self = Self(2);
16264 pub const IDR: Self = Self(5);
16265 pub const INVALID: Self = Self(2147483647);
16266}
16267
16268#[repr(transparent)]
16269#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16270pub struct StdVideoH264NonVclNaluType(pub i32);
16271impl StdVideoH264NonVclNaluType {
16272 pub const fn from_raw(value: i32) -> Self {
16273 Self(value)
16274 }
16275
16276 pub const fn as_raw(self) -> i32 {
16277 self.0
16278 }
16279
16280 pub const fn empty() -> Self {
16281 Self(0)
16282 }
16283
16284 pub const SPS: Self = Self(0);
16285 pub const PPS: Self = Self(1);
16286 pub const AUD: Self = Self(2);
16287 pub const PREFIX: Self = Self(3);
16288 pub const END_OF_SEQUENCE: Self = Self(4);
16289 pub const END_OF_STREAM: Self = Self(5);
16290 pub const PRECODED: Self = Self(6);
16291 pub const INVALID: Self = Self(2147483647);
16292}
16293
16294#[repr(transparent)]
16295#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16296pub struct StdVideoDecodeH264FieldOrderCount(pub i32);
16297impl StdVideoDecodeH264FieldOrderCount {
16298 pub const fn from_raw(value: i32) -> Self {
16299 Self(value)
16300 }
16301
16302 pub const fn as_raw(self) -> i32 {
16303 self.0
16304 }
16305
16306 pub const fn empty() -> Self {
16307 Self(0)
16308 }
16309
16310 pub const TOP: Self = Self(0);
16311 pub const BOTTOM: Self = Self(1);
16312 pub const INVALID: Self = Self(2147483647);
16313}
16314
16315#[repr(transparent)]
16316#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16317pub struct StdVideoH265ChromaFormatIdc(pub i32);
16318impl StdVideoH265ChromaFormatIdc {
16319 pub const fn from_raw(value: i32) -> Self {
16320 Self(value)
16321 }
16322
16323 pub const fn as_raw(self) -> i32 {
16324 self.0
16325 }
16326
16327 pub const fn empty() -> Self {
16328 Self(0)
16329 }
16330
16331 pub const MONOCHROME: Self = Self(0);
16332 pub const _420: Self = Self(1);
16333 pub const _422: Self = Self(2);
16334 pub const _444: Self = Self(3);
16335 pub const INVALID: Self = Self(2147483647);
16336}
16337
16338#[repr(transparent)]
16339#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16340pub struct StdVideoH265ProfileIdc(pub i32);
16341impl StdVideoH265ProfileIdc {
16342 pub const fn from_raw(value: i32) -> Self {
16343 Self(value)
16344 }
16345
16346 pub const fn as_raw(self) -> i32 {
16347 self.0
16348 }
16349
16350 pub const fn empty() -> Self {
16351 Self(0)
16352 }
16353
16354 pub const MAIN: Self = Self(1);
16355 pub const MAIN_10: Self = Self(2);
16356 pub const MAIN_STILL_PICTURE: Self = Self(3);
16357 pub const FORMAT_RANGE_EXTENSIONS: Self = Self(4);
16358 pub const SCC_EXTENSIONS: Self = Self(9);
16359 pub const INVALID: Self = Self(2147483647);
16360}
16361
16362#[repr(transparent)]
16363#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16364pub struct StdVideoH265LevelIdc(pub i32);
16365impl StdVideoH265LevelIdc {
16366 pub const fn from_raw(value: i32) -> Self {
16367 Self(value)
16368 }
16369
16370 pub const fn as_raw(self) -> i32 {
16371 self.0
16372 }
16373
16374 pub const fn empty() -> Self {
16375 Self(0)
16376 }
16377
16378 pub const _1_0: Self = Self(0);
16379 pub const _2_0: Self = Self(1);
16380 pub const _2_1: Self = Self(2);
16381 pub const _3_0: Self = Self(3);
16382 pub const _3_1: Self = Self(4);
16383 pub const _4_0: Self = Self(5);
16384 pub const _4_1: Self = Self(6);
16385 pub const _5_0: Self = Self(7);
16386 pub const _5_1: Self = Self(8);
16387 pub const _5_2: Self = Self(9);
16388 pub const _6_0: Self = Self(10);
16389 pub const _6_1: Self = Self(11);
16390 pub const _6_2: Self = Self(12);
16391 pub const INVALID: Self = Self(2147483647);
16392}
16393
16394#[repr(transparent)]
16395#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16396pub struct StdVideoH265SliceType(pub i32);
16397impl StdVideoH265SliceType {
16398 pub const fn from_raw(value: i32) -> Self {
16399 Self(value)
16400 }
16401
16402 pub const fn as_raw(self) -> i32 {
16403 self.0
16404 }
16405
16406 pub const fn empty() -> Self {
16407 Self(0)
16408 }
16409
16410 pub const B: Self = Self(0);
16411 pub const P: Self = Self(1);
16412 pub const I: Self = Self(2);
16413 pub const INVALID: Self = Self(2147483647);
16414}
16415
16416#[repr(transparent)]
16417#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16418pub struct StdVideoH265PictureType(pub i32);
16419impl StdVideoH265PictureType {
16420 pub const fn from_raw(value: i32) -> Self {
16421 Self(value)
16422 }
16423
16424 pub const fn as_raw(self) -> i32 {
16425 self.0
16426 }
16427
16428 pub const fn empty() -> Self {
16429 Self(0)
16430 }
16431
16432 pub const P: Self = Self(0);
16433 pub const B: Self = Self(1);
16434 pub const I: Self = Self(2);
16435 pub const IDR: Self = Self(3);
16436 pub const INVALID: Self = Self(2147483647);
16437}
16438
16439#[repr(transparent)]
16440#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16441pub struct StdVideoH265AspectRatioIdc(pub i32);
16442impl StdVideoH265AspectRatioIdc {
16443 pub const fn from_raw(value: i32) -> Self {
16444 Self(value)
16445 }
16446
16447 pub const fn as_raw(self) -> i32 {
16448 self.0
16449 }
16450
16451 pub const fn empty() -> Self {
16452 Self(0)
16453 }
16454
16455 pub const UNSPECIFIED: Self = Self(0);
16456 pub const SQUARE: Self = Self(1);
16457 pub const _12_11: Self = Self(2);
16458 pub const _10_11: Self = Self(3);
16459 pub const _16_11: Self = Self(4);
16460 pub const _40_33: Self = Self(5);
16461 pub const _24_11: Self = Self(6);
16462 pub const _20_11: Self = Self(7);
16463 pub const _32_11: Self = Self(8);
16464 pub const _80_33: Self = Self(9);
16465 pub const _18_11: Self = Self(10);
16466 pub const _15_11: Self = Self(11);
16467 pub const _64_33: Self = Self(12);
16468 pub const _160_99: Self = Self(13);
16469 pub const _4_3: Self = Self(14);
16470 pub const _3_2: Self = Self(15);
16471 pub const _2_1: Self = Self(16);
16472 pub const EXTENDED_SAR: Self = Self(255);
16473 pub const INVALID: Self = Self(2147483647);
16474}
16475
16476#[repr(transparent)]
16477#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16478pub struct StdVideoVP9Profile(pub i32);
16479impl StdVideoVP9Profile {
16480 pub const fn from_raw(value: i32) -> Self {
16481 Self(value)
16482 }
16483
16484 pub const fn as_raw(self) -> i32 {
16485 self.0
16486 }
16487
16488 pub const fn empty() -> Self {
16489 Self(0)
16490 }
16491
16492 pub const _0: Self = Self(0);
16493 pub const _1: Self = Self(1);
16494 pub const _2: Self = Self(2);
16495 pub const _3: Self = Self(3);
16496 pub const INVALID: Self = Self(2147483647);
16497}
16498
16499#[repr(transparent)]
16500#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16501pub struct StdVideoVP9Level(pub i32);
16502impl StdVideoVP9Level {
16503 pub const fn from_raw(value: i32) -> Self {
16504 Self(value)
16505 }
16506
16507 pub const fn as_raw(self) -> i32 {
16508 self.0
16509 }
16510
16511 pub const fn empty() -> Self {
16512 Self(0)
16513 }
16514
16515 pub const _1_0: Self = Self(0);
16516 pub const _1_1: Self = Self(1);
16517 pub const _2_0: Self = Self(2);
16518 pub const _2_1: Self = Self(3);
16519 pub const _3_0: Self = Self(4);
16520 pub const _3_1: Self = Self(5);
16521 pub const _4_0: Self = Self(6);
16522 pub const _4_1: Self = Self(7);
16523 pub const _5_0: Self = Self(8);
16524 pub const _5_1: Self = Self(9);
16525 pub const _5_2: Self = Self(10);
16526 pub const _6_0: Self = Self(11);
16527 pub const _6_1: Self = Self(12);
16528 pub const _6_2: Self = Self(13);
16529 pub const INVALID: Self = Self(2147483647);
16530}
16531
16532#[repr(transparent)]
16533#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16534pub struct StdVideoVP9FrameType(pub i32);
16535impl StdVideoVP9FrameType {
16536 pub const fn from_raw(value: i32) -> Self {
16537 Self(value)
16538 }
16539
16540 pub const fn as_raw(self) -> i32 {
16541 self.0
16542 }
16543
16544 pub const fn empty() -> Self {
16545 Self(0)
16546 }
16547
16548 pub const KEY: Self = Self(0);
16549 pub const NON_KEY: Self = Self(1);
16550 pub const INVALID: Self = Self(2147483647);
16551}
16552
16553#[repr(transparent)]
16554#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16555pub struct StdVideoVP9ReferenceName(pub i32);
16556impl StdVideoVP9ReferenceName {
16557 pub const fn from_raw(value: i32) -> Self {
16558 Self(value)
16559 }
16560
16561 pub const fn as_raw(self) -> i32 {
16562 self.0
16563 }
16564
16565 pub const fn empty() -> Self {
16566 Self(0)
16567 }
16568
16569 pub const INTRA_FRAME: Self = Self(0);
16570 pub const LAST_FRAME: Self = Self(1);
16571 pub const GOLDEN_FRAME: Self = Self(2);
16572 pub const ALTREF_FRAME: Self = Self(3);
16573 pub const INVALID: Self = Self(2147483647);
16574}
16575
16576#[repr(transparent)]
16577#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16578pub struct StdVideoVP9InterpolationFilter(pub i32);
16579impl StdVideoVP9InterpolationFilter {
16580 pub const fn from_raw(value: i32) -> Self {
16581 Self(value)
16582 }
16583
16584 pub const fn as_raw(self) -> i32 {
16585 self.0
16586 }
16587
16588 pub const fn empty() -> Self {
16589 Self(0)
16590 }
16591
16592 pub const EIGHTTAP: Self = Self(0);
16593 pub const EIGHTTAP_SMOOTH: Self = Self(1);
16594 pub const EIGHTTAP_SHARP: Self = Self(2);
16595 pub const BILINEAR: Self = Self(3);
16596 pub const SWITCHABLE: Self = Self(4);
16597 pub const INVALID: Self = Self(2147483647);
16598}
16599
16600#[repr(transparent)]
16601#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16602pub struct StdVideoVP9ColorSpace(pub i32);
16603impl StdVideoVP9ColorSpace {
16604 pub const fn from_raw(value: i32) -> Self {
16605 Self(value)
16606 }
16607
16608 pub const fn as_raw(self) -> i32 {
16609 self.0
16610 }
16611
16612 pub const fn empty() -> Self {
16613 Self(0)
16614 }
16615
16616 pub const UNKNOWN: Self = Self(0);
16617 pub const BT_601: Self = Self(1);
16618 pub const BT_709: Self = Self(2);
16619 pub const SMPTE_170: Self = Self(3);
16620 pub const SMPTE_240: Self = Self(4);
16621 pub const BT_2020: Self = Self(5);
16622 pub const RESERVED: Self = Self(6);
16623 pub const RGB: Self = Self(7);
16624 pub const INVALID: Self = Self(2147483647);
16625}
16626
16627#[repr(transparent)]
16628#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16629pub struct StdVideoAV1Profile(pub i32);
16630impl StdVideoAV1Profile {
16631 pub const fn from_raw(value: i32) -> Self {
16632 Self(value)
16633 }
16634
16635 pub const fn as_raw(self) -> i32 {
16636 self.0
16637 }
16638
16639 pub const fn empty() -> Self {
16640 Self(0)
16641 }
16642
16643 pub const MAIN: Self = Self(0);
16644 pub const HIGH: Self = Self(1);
16645 pub const PROFESSIONAL: Self = Self(2);
16646 pub const INVALID: Self = Self(2147483647);
16647}
16648
16649#[repr(transparent)]
16650#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16651pub struct StdVideoAV1Level(pub i32);
16652impl StdVideoAV1Level {
16653 pub const fn from_raw(value: i32) -> Self {
16654 Self(value)
16655 }
16656
16657 pub const fn as_raw(self) -> i32 {
16658 self.0
16659 }
16660
16661 pub const fn empty() -> Self {
16662 Self(0)
16663 }
16664
16665 pub const _2_0: Self = Self(0);
16666 pub const _2_1: Self = Self(1);
16667 pub const _2_2: Self = Self(2);
16668 pub const _2_3: Self = Self(3);
16669 pub const _3_0: Self = Self(4);
16670 pub const _3_1: Self = Self(5);
16671 pub const _3_2: Self = Self(6);
16672 pub const _3_3: Self = Self(7);
16673 pub const _4_0: Self = Self(8);
16674 pub const _4_1: Self = Self(9);
16675 pub const _4_2: Self = Self(10);
16676 pub const _4_3: Self = Self(11);
16677 pub const _5_0: Self = Self(12);
16678 pub const _5_1: Self = Self(13);
16679 pub const _5_2: Self = Self(14);
16680 pub const _5_3: Self = Self(15);
16681 pub const _6_0: Self = Self(16);
16682 pub const _6_1: Self = Self(17);
16683 pub const _6_2: Self = Self(18);
16684 pub const _6_3: Self = Self(19);
16685 pub const _7_0: Self = Self(20);
16686 pub const _7_1: Self = Self(21);
16687 pub const _7_2: Self = Self(22);
16688 pub const _7_3: Self = Self(23);
16689 pub const INVALID: Self = Self(2147483647);
16690}
16691
16692#[repr(transparent)]
16693#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16694pub struct StdVideoAV1FrameType(pub i32);
16695impl StdVideoAV1FrameType {
16696 pub const fn from_raw(value: i32) -> Self {
16697 Self(value)
16698 }
16699
16700 pub const fn as_raw(self) -> i32 {
16701 self.0
16702 }
16703
16704 pub const fn empty() -> Self {
16705 Self(0)
16706 }
16707
16708 pub const KEY: Self = Self(0);
16709 pub const INTER: Self = Self(1);
16710 pub const INTRA_ONLY: Self = Self(2);
16711 pub const SWITCH: Self = Self(3);
16712 pub const INVALID: Self = Self(2147483647);
16713}
16714
16715#[repr(transparent)]
16716#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16717pub struct StdVideoAV1ReferenceName(pub i32);
16718impl StdVideoAV1ReferenceName {
16719 pub const fn from_raw(value: i32) -> Self {
16720 Self(value)
16721 }
16722
16723 pub const fn as_raw(self) -> i32 {
16724 self.0
16725 }
16726
16727 pub const fn empty() -> Self {
16728 Self(0)
16729 }
16730
16731 pub const INTRA_FRAME: Self = Self(0);
16732 pub const LAST_FRAME: Self = Self(1);
16733 pub const LAST2_FRAME: Self = Self(2);
16734 pub const LAST3_FRAME: Self = Self(3);
16735 pub const GOLDEN_FRAME: Self = Self(4);
16736 pub const BWDREF_FRAME: Self = Self(5);
16737 pub const ALTREF2_FRAME: Self = Self(6);
16738 pub const ALTREF_FRAME: Self = Self(7);
16739 pub const INVALID: Self = Self(2147483647);
16740}
16741
16742#[repr(transparent)]
16743#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16744pub struct StdVideoAV1InterpolationFilter(pub i32);
16745impl StdVideoAV1InterpolationFilter {
16746 pub const fn from_raw(value: i32) -> Self {
16747 Self(value)
16748 }
16749
16750 pub const fn as_raw(self) -> i32 {
16751 self.0
16752 }
16753
16754 pub const fn empty() -> Self {
16755 Self(0)
16756 }
16757
16758 pub const EIGHTTAP: Self = Self(0);
16759 pub const EIGHTTAP_SMOOTH: Self = Self(1);
16760 pub const EIGHTTAP_SHARP: Self = Self(2);
16761 pub const BILINEAR: Self = Self(3);
16762 pub const SWITCHABLE: Self = Self(4);
16763 pub const INVALID: Self = Self(2147483647);
16764}
16765
16766#[repr(transparent)]
16767#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16768pub struct StdVideoAV1TxMode(pub i32);
16769impl StdVideoAV1TxMode {
16770 pub const fn from_raw(value: i32) -> Self {
16771 Self(value)
16772 }
16773
16774 pub const fn as_raw(self) -> i32 {
16775 self.0
16776 }
16777
16778 pub const fn empty() -> Self {
16779 Self(0)
16780 }
16781
16782 pub const ONLY_4X4: Self = Self(0);
16783 pub const LARGEST: Self = Self(1);
16784 pub const SELECT: Self = Self(2);
16785 pub const INVALID: Self = Self(2147483647);
16786}
16787
16788#[repr(transparent)]
16789#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16790pub struct StdVideoAV1FrameRestorationType(pub i32);
16791impl StdVideoAV1FrameRestorationType {
16792 pub const fn from_raw(value: i32) -> Self {
16793 Self(value)
16794 }
16795
16796 pub const fn as_raw(self) -> i32 {
16797 self.0
16798 }
16799
16800 pub const fn empty() -> Self {
16801 Self(0)
16802 }
16803
16804 pub const NONE: Self = Self(0);
16805 pub const WIENER: Self = Self(1);
16806 pub const SGRPROJ: Self = Self(2);
16807 pub const SWITCHABLE: Self = Self(3);
16808 pub const INVALID: Self = Self(2147483647);
16809}
16810
16811#[repr(transparent)]
16812#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16813pub struct StdVideoAV1ColorPrimaries(pub i32);
16814impl StdVideoAV1ColorPrimaries {
16815 pub const fn from_raw(value: i32) -> Self {
16816 Self(value)
16817 }
16818
16819 pub const fn as_raw(self) -> i32 {
16820 self.0
16821 }
16822
16823 pub const fn empty() -> Self {
16824 Self(0)
16825 }
16826
16827 pub const BT_709: Self = Self(1);
16828 pub const UNSPECIFIED: Self = Self(2);
16829 pub const BT_UNSPECIFIED: Self = Self(2);
16830 pub const BT_470_M: Self = Self(4);
16831 pub const BT_470_B_G: Self = Self(5);
16832 pub const BT_601: Self = Self(6);
16833 pub const SMPTE_240: Self = Self(7);
16834 pub const GENERIC_FILM: Self = Self(8);
16835 pub const BT_2020: Self = Self(9);
16836 pub const XYZ: Self = Self(10);
16837 pub const SMPTE_431: Self = Self(11);
16838 pub const SMPTE_432: Self = Self(12);
16839 pub const EBU_3213: Self = Self(22);
16840 pub const INVALID: Self = Self(2147483647);
16841}
16842
16843#[repr(transparent)]
16844#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16845pub struct StdVideoAV1TransferCharacteristics(pub i32);
16846impl StdVideoAV1TransferCharacteristics {
16847 pub const fn from_raw(value: i32) -> Self {
16848 Self(value)
16849 }
16850
16851 pub const fn as_raw(self) -> i32 {
16852 self.0
16853 }
16854
16855 pub const fn empty() -> Self {
16856 Self(0)
16857 }
16858
16859 pub const RESERVED_0: Self = Self(0);
16860 pub const BT_709: Self = Self(1);
16861 pub const UNSPECIFIED: Self = Self(2);
16862 pub const RESERVED_3: Self = Self(3);
16863 pub const BT_470_M: Self = Self(4);
16864 pub const BT_470_B_G: Self = Self(5);
16865 pub const BT_601: Self = Self(6);
16866 pub const SMPTE_240: Self = Self(7);
16867 pub const LINEAR: Self = Self(8);
16868 pub const LOG_100: Self = Self(9);
16869 pub const LOG_100_SQRT10: Self = Self(10);
16870 pub const IEC_61966: Self = Self(11);
16871 pub const BT_1361: Self = Self(12);
16872 pub const SRGB: Self = Self(13);
16873 pub const BT_2020_10_BIT: Self = Self(14);
16874 pub const BT_2020_12_BIT: Self = Self(15);
16875 pub const SMPTE_2084: Self = Self(16);
16876 pub const SMPTE_428: Self = Self(17);
16877 pub const HLG: Self = Self(18);
16878 pub const INVALID: Self = Self(2147483647);
16879}
16880
16881#[repr(transparent)]
16882#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16883pub struct StdVideoAV1MatrixCoefficients(pub i32);
16884impl StdVideoAV1MatrixCoefficients {
16885 pub const fn from_raw(value: i32) -> Self {
16886 Self(value)
16887 }
16888
16889 pub const fn as_raw(self) -> i32 {
16890 self.0
16891 }
16892
16893 pub const fn empty() -> Self {
16894 Self(0)
16895 }
16896
16897 pub const IDENTITY: Self = Self(0);
16898 pub const BT_709: Self = Self(1);
16899 pub const UNSPECIFIED: Self = Self(2);
16900 pub const RESERVED_3: Self = Self(3);
16901 pub const FCC: Self = Self(4);
16902 pub const BT_470_B_G: Self = Self(5);
16903 pub const BT_601: Self = Self(6);
16904 pub const SMPTE_240: Self = Self(7);
16905 pub const SMPTE_YCGCO: Self = Self(8);
16906 pub const BT_2020_NCL: Self = Self(9);
16907 pub const BT_2020_CL: Self = Self(10);
16908 pub const SMPTE_2085: Self = Self(11);
16909 pub const CHROMAT_NCL: Self = Self(12);
16910 pub const CHROMAT_CL: Self = Self(13);
16911 pub const ICTCP: Self = Self(14);
16912 pub const INVALID: Self = Self(2147483647);
16913}
16914
16915#[repr(transparent)]
16916#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
16917pub struct StdVideoAV1ChromaSamplePosition(pub i32);
16918impl StdVideoAV1ChromaSamplePosition {
16919 pub const fn from_raw(value: i32) -> Self {
16920 Self(value)
16921 }
16922
16923 pub const fn as_raw(self) -> i32 {
16924 self.0
16925 }
16926
16927 pub const fn empty() -> Self {
16928 Self(0)
16929 }
16930
16931 pub const UNKNOWN: Self = Self(0);
16932 pub const VERTICAL: Self = Self(1);
16933 pub const COLOCATED: Self = Self(2);
16934 pub const RESERVED: Self = Self(3);
16935 pub const INVALID: Self = Self(2147483647);
16936}
16937
16938impl Result {
16939 pub const fn is_success(self) -> bool {
16940 self.0 >= 0
16941 }
16942
16943 pub const fn is_err(self) -> bool {
16944 self.0 < 0
16945 }
16946}