1#[repr(transparent)]
3#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4#[doc(alias = "VkAccelerationStructureBuildTypeKHR")]
5pub struct AccelerationStructureBuildTypeKHR(i32);
6impl AccelerationStructureBuildTypeKHR {
7 pub const HOST: Self = Self(0i32);
8 pub const DEVICE: Self = Self(1i32);
9 pub const HOST_OR_DEVICE: Self = Self(2i32);
10 #[inline]
11 pub const fn from_raw(value: i32) -> Self {
12 Self(value)
13 }
14 #[inline]
15 pub const fn as_raw(self) -> i32 {
16 self.0
17 }
18}
19impl core::fmt::Debug for AccelerationStructureBuildTypeKHR {
20 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21 match self.0 {
22 0i32 => f.write_str("HOST"),
23 1i32 => f.write_str("DEVICE"),
24 2i32 => f.write_str("HOST_OR_DEVICE"),
25 other => {
26 write!(f, "{}({})", stringify!(AccelerationStructureBuildTypeKHR), other)
27 }
28 }
29 }
30}
31#[repr(transparent)]
33#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
34#[doc(alias = "VkAccelerationStructureCompatibilityKHR")]
35pub struct AccelerationStructureCompatibilityKHR(i32);
36impl AccelerationStructureCompatibilityKHR {
37 pub const COMPATIBLE: Self = Self(0i32);
38 pub const INCOMPATIBLE: Self = Self(1i32);
39 #[inline]
40 pub const fn from_raw(value: i32) -> Self {
41 Self(value)
42 }
43 #[inline]
44 pub const fn as_raw(self) -> i32 {
45 self.0
46 }
47}
48impl core::fmt::Debug for AccelerationStructureCompatibilityKHR {
49 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
50 match self.0 {
51 0i32 => f.write_str("COMPATIBLE"),
52 1i32 => f.write_str("INCOMPATIBLE"),
53 other => {
54 write!(
55 f, "{}({})", stringify!(AccelerationStructureCompatibilityKHR), other
56 )
57 }
58 }
59 }
60}
61#[repr(transparent)]
63#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
64#[doc(alias = "VkAccelerationStructureMemoryRequirementsTypeNV")]
65pub struct AccelerationStructureMemoryRequirementsTypeNV(i32);
66impl AccelerationStructureMemoryRequirementsTypeNV {
67 pub const OBJECT: Self = Self(0i32);
68 pub const BUILD_SCRATCH: Self = Self(1i32);
69 pub const UPDATE_SCRATCH: Self = Self(2i32);
70 #[inline]
71 pub const fn from_raw(value: i32) -> Self {
72 Self(value)
73 }
74 #[inline]
75 pub const fn as_raw(self) -> i32 {
76 self.0
77 }
78}
79impl core::fmt::Debug for AccelerationStructureMemoryRequirementsTypeNV {
80 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
81 match self.0 {
82 0i32 => f.write_str("OBJECT"),
83 1i32 => f.write_str("BUILD_SCRATCH"),
84 2i32 => f.write_str("UPDATE_SCRATCH"),
85 other => {
86 write!(
87 f, "{}({})",
88 stringify!(AccelerationStructureMemoryRequirementsTypeNV), other
89 )
90 }
91 }
92 }
93}
94#[repr(transparent)]
96#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
97#[doc(alias = "VkAccelerationStructureMotionInstanceTypeNV")]
98pub struct AccelerationStructureMotionInstanceTypeNV(i32);
99impl AccelerationStructureMotionInstanceTypeNV {
100 pub const STATIC: Self = Self(0i32);
101 pub const MATRIX_MOTION: Self = Self(1i32);
102 pub const SRT_MOTION: Self = Self(2i32);
103 #[inline]
104 pub const fn from_raw(value: i32) -> Self {
105 Self(value)
106 }
107 #[inline]
108 pub const fn as_raw(self) -> i32 {
109 self.0
110 }
111}
112impl core::fmt::Debug for AccelerationStructureMotionInstanceTypeNV {
113 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
114 match self.0 {
115 0i32 => f.write_str("STATIC"),
116 1i32 => f.write_str("MATRIX_MOTION"),
117 2i32 => f.write_str("SRT_MOTION"),
118 other => {
119 write!(
120 f, "{}({})", stringify!(AccelerationStructureMotionInstanceTypeNV),
121 other
122 )
123 }
124 }
125 }
126}
127#[repr(transparent)]
129#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
130#[doc(alias = "VkAccelerationStructureTypeKHR")]
131pub struct AccelerationStructureTypeKHR(i32);
132impl AccelerationStructureTypeKHR {
133 pub const TOP_LEVEL: Self = Self(0i32);
134 pub const BOTTOM_LEVEL: Self = Self(1i32);
135 pub const GENERIC: Self = Self(2i32);
136 #[inline]
137 pub const fn from_raw(value: i32) -> Self {
138 Self(value)
139 }
140 #[inline]
141 pub const fn as_raw(self) -> i32 {
142 self.0
143 }
144}
145impl core::fmt::Debug for AccelerationStructureTypeKHR {
146 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
147 match self.0 {
148 0i32 => f.write_str("TOP_LEVEL"),
149 1i32 => f.write_str("BOTTOM_LEVEL"),
150 2i32 => f.write_str("GENERIC"),
151 other => write!(f, "{}({})", stringify!(AccelerationStructureTypeKHR), other),
152 }
153 }
154}
155#[repr(transparent)]
157#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
158#[doc(alias = "VkAntiLagModeAMD")]
159pub struct AntiLagModeAMD(i32);
160impl AntiLagModeAMD {
161 pub const DRIVER_CONTROL: Self = Self(0i32);
162 pub const ON: Self = Self(1i32);
163 pub const OFF: Self = Self(2i32);
164 #[inline]
165 pub const fn from_raw(value: i32) -> Self {
166 Self(value)
167 }
168 #[inline]
169 pub const fn as_raw(self) -> i32 {
170 self.0
171 }
172}
173impl core::fmt::Debug for AntiLagModeAMD {
174 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
175 match self.0 {
176 0i32 => f.write_str("DRIVER_CONTROL"),
177 1i32 => f.write_str("ON"),
178 2i32 => f.write_str("OFF"),
179 other => write!(f, "{}({})", stringify!(AntiLagModeAMD), other),
180 }
181 }
182}
183#[repr(transparent)]
185#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
186#[doc(alias = "VkAntiLagStageAMD")]
187pub struct AntiLagStageAMD(i32);
188impl AntiLagStageAMD {
189 pub const INPUT: Self = Self(0i32);
190 pub const PRESENT: Self = Self(1i32);
191 #[inline]
192 pub const fn from_raw(value: i32) -> Self {
193 Self(value)
194 }
195 #[inline]
196 pub const fn as_raw(self) -> i32 {
197 self.0
198 }
199}
200impl core::fmt::Debug for AntiLagStageAMD {
201 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
202 match self.0 {
203 0i32 => f.write_str("INPUT"),
204 1i32 => f.write_str("PRESENT"),
205 other => write!(f, "{}({})", stringify!(AntiLagStageAMD), other),
206 }
207 }
208}
209#[repr(transparent)]
211#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
212#[doc(alias = "VkAttachmentLoadOp")]
213pub struct AttachmentLoadOp(i32);
214impl AttachmentLoadOp {
215 pub const LOAD: Self = Self(0i32);
216 pub const CLEAR: Self = Self(1i32);
217 pub const DONT_CARE: Self = Self(2i32);
218 pub const NONE: Self = Self(1000400000i32);
219 #[inline]
220 pub const fn from_raw(value: i32) -> Self {
221 Self(value)
222 }
223 #[inline]
224 pub const fn as_raw(self) -> i32 {
225 self.0
226 }
227}
228impl core::fmt::Debug for AttachmentLoadOp {
229 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
230 match self.0 {
231 0i32 => f.write_str("LOAD"),
232 1i32 => f.write_str("CLEAR"),
233 2i32 => f.write_str("DONT_CARE"),
234 1000400000i32 => f.write_str("NONE"),
235 other => write!(f, "{}({})", stringify!(AttachmentLoadOp), other),
236 }
237 }
238}
239#[repr(transparent)]
241#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
242#[doc(alias = "VkAttachmentStoreOp")]
243pub struct AttachmentStoreOp(i32);
244impl AttachmentStoreOp {
245 pub const STORE: Self = Self(0i32);
246 pub const DONT_CARE: Self = Self(1i32);
247 pub const NONE: Self = Self(1000301000i32);
248 #[inline]
249 pub const fn from_raw(value: i32) -> Self {
250 Self(value)
251 }
252 #[inline]
253 pub const fn as_raw(self) -> i32 {
254 self.0
255 }
256}
257impl core::fmt::Debug for AttachmentStoreOp {
258 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
259 match self.0 {
260 0i32 => f.write_str("STORE"),
261 1i32 => f.write_str("DONT_CARE"),
262 1000301000i32 => f.write_str("NONE"),
263 other => write!(f, "{}({})", stringify!(AttachmentStoreOp), other),
264 }
265 }
266}
267#[repr(transparent)]
269#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
270#[doc(alias = "VkBlendFactor")]
271pub struct BlendFactor(i32);
272impl BlendFactor {
273 pub const ZERO: Self = Self(0i32);
274 pub const ONE: Self = Self(1i32);
275 pub const SRC_COLOR: Self = Self(2i32);
276 pub const ONE_MINUS_SRC_COLOR: Self = Self(3i32);
277 pub const DST_COLOR: Self = Self(4i32);
278 pub const ONE_MINUS_DST_COLOR: Self = Self(5i32);
279 pub const SRC_ALPHA: Self = Self(6i32);
280 pub const ONE_MINUS_SRC_ALPHA: Self = Self(7i32);
281 pub const DST_ALPHA: Self = Self(8i32);
282 pub const ONE_MINUS_DST_ALPHA: Self = Self(9i32);
283 pub const CONSTANT_COLOR: Self = Self(10i32);
284 pub const ONE_MINUS_CONSTANT_COLOR: Self = Self(11i32);
285 pub const CONSTANT_ALPHA: Self = Self(12i32);
286 pub const ONE_MINUS_CONSTANT_ALPHA: Self = Self(13i32);
287 pub const SRC_ALPHA_SATURATE: Self = Self(14i32);
288 pub const SRC1_COLOR: Self = Self(15i32);
289 pub const ONE_MINUS_SRC1_COLOR: Self = Self(16i32);
290 pub const SRC1_ALPHA: Self = Self(17i32);
291 pub const ONE_MINUS_SRC1_ALPHA: Self = Self(18i32);
292 #[inline]
293 pub const fn from_raw(value: i32) -> Self {
294 Self(value)
295 }
296 #[inline]
297 pub const fn as_raw(self) -> i32 {
298 self.0
299 }
300}
301impl core::fmt::Debug for BlendFactor {
302 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
303 match self.0 {
304 0i32 => f.write_str("ZERO"),
305 1i32 => f.write_str("ONE"),
306 2i32 => f.write_str("SRC_COLOR"),
307 3i32 => f.write_str("ONE_MINUS_SRC_COLOR"),
308 4i32 => f.write_str("DST_COLOR"),
309 5i32 => f.write_str("ONE_MINUS_DST_COLOR"),
310 6i32 => f.write_str("SRC_ALPHA"),
311 7i32 => f.write_str("ONE_MINUS_SRC_ALPHA"),
312 8i32 => f.write_str("DST_ALPHA"),
313 9i32 => f.write_str("ONE_MINUS_DST_ALPHA"),
314 10i32 => f.write_str("CONSTANT_COLOR"),
315 11i32 => f.write_str("ONE_MINUS_CONSTANT_COLOR"),
316 12i32 => f.write_str("CONSTANT_ALPHA"),
317 13i32 => f.write_str("ONE_MINUS_CONSTANT_ALPHA"),
318 14i32 => f.write_str("SRC_ALPHA_SATURATE"),
319 15i32 => f.write_str("SRC1_COLOR"),
320 16i32 => f.write_str("ONE_MINUS_SRC1_COLOR"),
321 17i32 => f.write_str("SRC1_ALPHA"),
322 18i32 => f.write_str("ONE_MINUS_SRC1_ALPHA"),
323 other => write!(f, "{}({})", stringify!(BlendFactor), other),
324 }
325 }
326}
327#[repr(transparent)]
329#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
330#[doc(alias = "VkBlendOp")]
331pub struct BlendOp(i32);
332impl BlendOp {
333 pub const ADD: Self = Self(0i32);
334 pub const SUBTRACT: Self = Self(1i32);
335 pub const REVERSE_SUBTRACT: Self = Self(2i32);
336 pub const MIN: Self = Self(3i32);
337 pub const MAX: Self = Self(4i32);
338 pub const ZERO: Self = Self(1000148000i32);
339 pub const SRC: Self = Self(1000148001i32);
340 pub const DST: Self = Self(1000148002i32);
341 pub const SRC_OVER: Self = Self(1000148003i32);
342 pub const DST_OVER: Self = Self(1000148004i32);
343 pub const SRC_IN: Self = Self(1000148005i32);
344 pub const DST_IN: Self = Self(1000148006i32);
345 pub const SRC_OUT: Self = Self(1000148007i32);
346 pub const DST_OUT: Self = Self(1000148008i32);
347 pub const SRC_ATOP: Self = Self(1000148009i32);
348 pub const DST_ATOP: Self = Self(1000148010i32);
349 pub const XOR: Self = Self(1000148011i32);
350 pub const MULTIPLY: Self = Self(1000148012i32);
351 pub const SCREEN: Self = Self(1000148013i32);
352 pub const OVERLAY: Self = Self(1000148014i32);
353 pub const DARKEN: Self = Self(1000148015i32);
354 pub const LIGHTEN: Self = Self(1000148016i32);
355 pub const COLORDODGE: Self = Self(1000148017i32);
356 pub const COLORBURN: Self = Self(1000148018i32);
357 pub const HARDLIGHT: Self = Self(1000148019i32);
358 pub const SOFTLIGHT: Self = Self(1000148020i32);
359 pub const DIFFERENCE: Self = Self(1000148021i32);
360 pub const EXCLUSION: Self = Self(1000148022i32);
361 pub const INVERT: Self = Self(1000148023i32);
362 pub const INVERT_RGB: Self = Self(1000148024i32);
363 pub const LINEARDODGE: Self = Self(1000148025i32);
364 pub const LINEARBURN: Self = Self(1000148026i32);
365 pub const VIVIDLIGHT: Self = Self(1000148027i32);
366 pub const LINEARLIGHT: Self = Self(1000148028i32);
367 pub const PINLIGHT: Self = Self(1000148029i32);
368 pub const HARDMIX: Self = Self(1000148030i32);
369 pub const HSL_HUE: Self = Self(1000148031i32);
370 pub const HSL_SATURATION: Self = Self(1000148032i32);
371 pub const HSL_COLOR: Self = Self(1000148033i32);
372 pub const HSL_LUMINOSITY: Self = Self(1000148034i32);
373 pub const PLUS: Self = Self(1000148035i32);
374 pub const PLUS_CLAMPED: Self = Self(1000148036i32);
375 pub const PLUS_CLAMPED_ALPHA: Self = Self(1000148037i32);
376 pub const PLUS_DARKER: Self = Self(1000148038i32);
377 pub const MINUS: Self = Self(1000148039i32);
378 pub const MINUS_CLAMPED: Self = Self(1000148040i32);
379 pub const CONTRAST: Self = Self(1000148041i32);
380 pub const INVERT_OVG: Self = Self(1000148042i32);
381 pub const RED: Self = Self(1000148043i32);
382 pub const GREEN: Self = Self(1000148044i32);
383 pub const BLUE: Self = Self(1000148045i32);
384 #[inline]
385 pub const fn from_raw(value: i32) -> Self {
386 Self(value)
387 }
388 #[inline]
389 pub const fn as_raw(self) -> i32 {
390 self.0
391 }
392}
393impl core::fmt::Debug for BlendOp {
394 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
395 match self.0 {
396 0i32 => f.write_str("ADD"),
397 1i32 => f.write_str("SUBTRACT"),
398 2i32 => f.write_str("REVERSE_SUBTRACT"),
399 3i32 => f.write_str("MIN"),
400 4i32 => f.write_str("MAX"),
401 1000148000i32 => f.write_str("ZERO"),
402 1000148001i32 => f.write_str("SRC"),
403 1000148002i32 => f.write_str("DST"),
404 1000148003i32 => f.write_str("SRC_OVER"),
405 1000148004i32 => f.write_str("DST_OVER"),
406 1000148005i32 => f.write_str("SRC_IN"),
407 1000148006i32 => f.write_str("DST_IN"),
408 1000148007i32 => f.write_str("SRC_OUT"),
409 1000148008i32 => f.write_str("DST_OUT"),
410 1000148009i32 => f.write_str("SRC_ATOP"),
411 1000148010i32 => f.write_str("DST_ATOP"),
412 1000148011i32 => f.write_str("XOR"),
413 1000148012i32 => f.write_str("MULTIPLY"),
414 1000148013i32 => f.write_str("SCREEN"),
415 1000148014i32 => f.write_str("OVERLAY"),
416 1000148015i32 => f.write_str("DARKEN"),
417 1000148016i32 => f.write_str("LIGHTEN"),
418 1000148017i32 => f.write_str("COLORDODGE"),
419 1000148018i32 => f.write_str("COLORBURN"),
420 1000148019i32 => f.write_str("HARDLIGHT"),
421 1000148020i32 => f.write_str("SOFTLIGHT"),
422 1000148021i32 => f.write_str("DIFFERENCE"),
423 1000148022i32 => f.write_str("EXCLUSION"),
424 1000148023i32 => f.write_str("INVERT"),
425 1000148024i32 => f.write_str("INVERT_RGB"),
426 1000148025i32 => f.write_str("LINEARDODGE"),
427 1000148026i32 => f.write_str("LINEARBURN"),
428 1000148027i32 => f.write_str("VIVIDLIGHT"),
429 1000148028i32 => f.write_str("LINEARLIGHT"),
430 1000148029i32 => f.write_str("PINLIGHT"),
431 1000148030i32 => f.write_str("HARDMIX"),
432 1000148031i32 => f.write_str("HSL_HUE"),
433 1000148032i32 => f.write_str("HSL_SATURATION"),
434 1000148033i32 => f.write_str("HSL_COLOR"),
435 1000148034i32 => f.write_str("HSL_LUMINOSITY"),
436 1000148035i32 => f.write_str("PLUS"),
437 1000148036i32 => f.write_str("PLUS_CLAMPED"),
438 1000148037i32 => f.write_str("PLUS_CLAMPED_ALPHA"),
439 1000148038i32 => f.write_str("PLUS_DARKER"),
440 1000148039i32 => f.write_str("MINUS"),
441 1000148040i32 => f.write_str("MINUS_CLAMPED"),
442 1000148041i32 => f.write_str("CONTRAST"),
443 1000148042i32 => f.write_str("INVERT_OVG"),
444 1000148043i32 => f.write_str("RED"),
445 1000148044i32 => f.write_str("GREEN"),
446 1000148045i32 => f.write_str("BLUE"),
447 other => write!(f, "{}({})", stringify!(BlendOp), other),
448 }
449 }
450}
451#[repr(transparent)]
453#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
454#[doc(alias = "VkBlendOverlapEXT")]
455pub struct BlendOverlapEXT(i32);
456impl BlendOverlapEXT {
457 pub const UNCORRELATED: Self = Self(0i32);
458 pub const DISJOINT: Self = Self(1i32);
459 pub const CONJOINT: Self = Self(2i32);
460 #[inline]
461 pub const fn from_raw(value: i32) -> Self {
462 Self(value)
463 }
464 #[inline]
465 pub const fn as_raw(self) -> i32 {
466 self.0
467 }
468}
469impl core::fmt::Debug for BlendOverlapEXT {
470 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
471 match self.0 {
472 0i32 => f.write_str("UNCORRELATED"),
473 1i32 => f.write_str("DISJOINT"),
474 2i32 => f.write_str("CONJOINT"),
475 other => write!(f, "{}({})", stringify!(BlendOverlapEXT), other),
476 }
477 }
478}
479#[repr(transparent)]
481#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
482#[doc(alias = "VkBlockMatchWindowCompareModeQCOM")]
483pub struct BlockMatchWindowCompareModeQCOM(i32);
484impl BlockMatchWindowCompareModeQCOM {
485 pub const MIN: Self = Self(0i32);
486 pub const MAX: Self = Self(1i32);
487 #[inline]
488 pub const fn from_raw(value: i32) -> Self {
489 Self(value)
490 }
491 #[inline]
492 pub const fn as_raw(self) -> i32 {
493 self.0
494 }
495}
496impl core::fmt::Debug for BlockMatchWindowCompareModeQCOM {
497 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
498 match self.0 {
499 0i32 => f.write_str("MIN"),
500 1i32 => f.write_str("MAX"),
501 other => {
502 write!(f, "{}({})", stringify!(BlockMatchWindowCompareModeQCOM), other)
503 }
504 }
505 }
506}
507#[repr(transparent)]
509#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
510#[doc(alias = "VkBorderColor")]
511pub struct BorderColor(i32);
512impl BorderColor {
513 pub const FLOAT_TRANSPARENT_BLACK: Self = Self(0i32);
514 pub const INT_TRANSPARENT_BLACK: Self = Self(1i32);
515 pub const FLOAT_OPAQUE_BLACK: Self = Self(2i32);
516 pub const INT_OPAQUE_BLACK: Self = Self(3i32);
517 pub const FLOAT_OPAQUE_WHITE: Self = Self(4i32);
518 pub const INT_OPAQUE_WHITE: Self = Self(5i32);
519 pub const FLOAT_CUSTOM: Self = Self(1000287003i32);
520 pub const INT_CUSTOM: Self = Self(1000287004i32);
521 #[inline]
522 pub const fn from_raw(value: i32) -> Self {
523 Self(value)
524 }
525 #[inline]
526 pub const fn as_raw(self) -> i32 {
527 self.0
528 }
529}
530impl core::fmt::Debug for BorderColor {
531 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
532 match self.0 {
533 0i32 => f.write_str("FLOAT_TRANSPARENT_BLACK"),
534 1i32 => f.write_str("INT_TRANSPARENT_BLACK"),
535 2i32 => f.write_str("FLOAT_OPAQUE_BLACK"),
536 3i32 => f.write_str("INT_OPAQUE_BLACK"),
537 4i32 => f.write_str("FLOAT_OPAQUE_WHITE"),
538 5i32 => f.write_str("INT_OPAQUE_WHITE"),
539 1000287003i32 => f.write_str("FLOAT_CUSTOM"),
540 1000287004i32 => f.write_str("INT_CUSTOM"),
541 other => write!(f, "{}({})", stringify!(BorderColor), other),
542 }
543 }
544}
545#[repr(transparent)]
547#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
548#[doc(alias = "VkBuildAccelerationStructureModeKHR")]
549pub struct BuildAccelerationStructureModeKHR(i32);
550impl BuildAccelerationStructureModeKHR {
551 pub const BUILD: Self = Self(0i32);
552 pub const UPDATE: Self = Self(1i32);
553 #[inline]
554 pub const fn from_raw(value: i32) -> Self {
555 Self(value)
556 }
557 #[inline]
558 pub const fn as_raw(self) -> i32 {
559 self.0
560 }
561}
562impl core::fmt::Debug for BuildAccelerationStructureModeKHR {
563 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
564 match self.0 {
565 0i32 => f.write_str("BUILD"),
566 1i32 => f.write_str("UPDATE"),
567 other => {
568 write!(f, "{}({})", stringify!(BuildAccelerationStructureModeKHR), other)
569 }
570 }
571 }
572}
573#[repr(transparent)]
575#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
576#[doc(alias = "VkBuildMicromapModeEXT")]
577pub struct BuildMicromapModeEXT(i32);
578impl BuildMicromapModeEXT {
579 pub const BUILD: Self = Self(0i32);
580 #[inline]
581 pub const fn from_raw(value: i32) -> Self {
582 Self(value)
583 }
584 #[inline]
585 pub const fn as_raw(self) -> i32 {
586 self.0
587 }
588}
589impl core::fmt::Debug for BuildMicromapModeEXT {
590 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
591 match self.0 {
592 0i32 => f.write_str("BUILD"),
593 other => write!(f, "{}({})", stringify!(BuildMicromapModeEXT), other),
594 }
595 }
596}
597#[repr(transparent)]
599#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
600#[doc(alias = "VkChromaLocation")]
601pub struct ChromaLocation(i32);
602impl ChromaLocation {
603 pub const COSITED_EVEN: Self = Self(0i32);
604 pub const MIDPOINT: Self = Self(1i32);
605 #[inline]
606 pub const fn from_raw(value: i32) -> Self {
607 Self(value)
608 }
609 #[inline]
610 pub const fn as_raw(self) -> i32 {
611 self.0
612 }
613}
614impl core::fmt::Debug for ChromaLocation {
615 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
616 match self.0 {
617 0i32 => f.write_str("COSITED_EVEN"),
618 1i32 => f.write_str("MIDPOINT"),
619 other => write!(f, "{}({})", stringify!(ChromaLocation), other),
620 }
621 }
622}
623#[repr(transparent)]
625#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
626#[doc(alias = "VkClusterAccelerationStructureOpModeNV")]
627pub struct ClusterAccelerationStructureOpModeNV(i32);
628impl ClusterAccelerationStructureOpModeNV {
629 pub const IMPLICIT_DESTINATIONS: Self = Self(0i32);
630 pub const EXPLICIT_DESTINATIONS: Self = Self(1i32);
631 pub const COMPUTE_SIZES: Self = Self(2i32);
632 #[inline]
633 pub const fn from_raw(value: i32) -> Self {
634 Self(value)
635 }
636 #[inline]
637 pub const fn as_raw(self) -> i32 {
638 self.0
639 }
640}
641impl core::fmt::Debug for ClusterAccelerationStructureOpModeNV {
642 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
643 match self.0 {
644 0i32 => f.write_str("IMPLICIT_DESTINATIONS"),
645 1i32 => f.write_str("EXPLICIT_DESTINATIONS"),
646 2i32 => f.write_str("COMPUTE_SIZES"),
647 other => {
648 write!(
649 f, "{}({})", stringify!(ClusterAccelerationStructureOpModeNV), other
650 )
651 }
652 }
653 }
654}
655#[repr(transparent)]
657#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
658#[doc(alias = "VkClusterAccelerationStructureOpTypeNV")]
659pub struct ClusterAccelerationStructureOpTypeNV(i32);
660impl ClusterAccelerationStructureOpTypeNV {
661 pub const MOVE_OBJECTS: Self = Self(0i32);
662 pub const BUILD_CLUSTERS_BOTTOM_LEVEL: Self = Self(1i32);
663 pub const BUILD_TRIANGLE_CLUSTER: Self = Self(2i32);
664 pub const BUILD_TRIANGLE_CLUSTER_TEMPLATE: Self = Self(3i32);
665 pub const INSTANTIATE_TRIANGLE_CLUSTER: Self = Self(4i32);
666 pub const GET_CLUSTER_TEMPLATE_INDICES: Self = Self(5i32);
667 #[inline]
668 pub const fn from_raw(value: i32) -> Self {
669 Self(value)
670 }
671 #[inline]
672 pub const fn as_raw(self) -> i32 {
673 self.0
674 }
675}
676impl core::fmt::Debug for ClusterAccelerationStructureOpTypeNV {
677 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
678 match self.0 {
679 0i32 => f.write_str("MOVE_OBJECTS"),
680 1i32 => f.write_str("BUILD_CLUSTERS_BOTTOM_LEVEL"),
681 2i32 => f.write_str("BUILD_TRIANGLE_CLUSTER"),
682 3i32 => f.write_str("BUILD_TRIANGLE_CLUSTER_TEMPLATE"),
683 4i32 => f.write_str("INSTANTIATE_TRIANGLE_CLUSTER"),
684 5i32 => f.write_str("GET_CLUSTER_TEMPLATE_INDICES"),
685 other => {
686 write!(
687 f, "{}({})", stringify!(ClusterAccelerationStructureOpTypeNV), other
688 )
689 }
690 }
691 }
692}
693#[repr(transparent)]
695#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
696#[doc(alias = "VkClusterAccelerationStructureTypeNV")]
697pub struct ClusterAccelerationStructureTypeNV(i32);
698impl ClusterAccelerationStructureTypeNV {
699 pub const CLUSTERS_BOTTOM_LEVEL: Self = Self(0i32);
700 pub const TRIANGLE_CLUSTER: Self = Self(1i32);
701 pub const TRIANGLE_CLUSTER_TEMPLATE: Self = Self(2i32);
702 #[inline]
703 pub const fn from_raw(value: i32) -> Self {
704 Self(value)
705 }
706 #[inline]
707 pub const fn as_raw(self) -> i32 {
708 self.0
709 }
710}
711impl core::fmt::Debug for ClusterAccelerationStructureTypeNV {
712 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
713 match self.0 {
714 0i32 => f.write_str("CLUSTERS_BOTTOM_LEVEL"),
715 1i32 => f.write_str("TRIANGLE_CLUSTER"),
716 2i32 => f.write_str("TRIANGLE_CLUSTER_TEMPLATE"),
717 other => {
718 write!(
719 f, "{}({})", stringify!(ClusterAccelerationStructureTypeNV), other
720 )
721 }
722 }
723 }
724}
725#[repr(transparent)]
727#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
728#[doc(alias = "VkCoarseSampleOrderTypeNV")]
729pub struct CoarseSampleOrderTypeNV(i32);
730impl CoarseSampleOrderTypeNV {
731 pub const DEFAULT: Self = Self(0i32);
732 pub const CUSTOM: Self = Self(1i32);
733 pub const PIXEL_MAJOR: Self = Self(2i32);
734 pub const SAMPLE_MAJOR: Self = Self(3i32);
735 #[inline]
736 pub const fn from_raw(value: i32) -> Self {
737 Self(value)
738 }
739 #[inline]
740 pub const fn as_raw(self) -> i32 {
741 self.0
742 }
743}
744impl core::fmt::Debug for CoarseSampleOrderTypeNV {
745 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
746 match self.0 {
747 0i32 => f.write_str("DEFAULT"),
748 1i32 => f.write_str("CUSTOM"),
749 2i32 => f.write_str("PIXEL_MAJOR"),
750 3i32 => f.write_str("SAMPLE_MAJOR"),
751 other => write!(f, "{}({})", stringify!(CoarseSampleOrderTypeNV), other),
752 }
753 }
754}
755#[repr(transparent)]
757#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
758#[doc(alias = "VkColorSpaceKHR")]
759pub struct ColorSpaceKHR(i32);
760impl ColorSpaceKHR {
761 pub const SRGB_NONLINEAR: Self = Self(0i32);
762 pub const COLORSPACE_SRGB_NONLINEAR: Self = Self::SRGB_NONLINEAR;
763 pub const DISPLAY_P3_NONLINEAR: Self = Self(1000104001i32);
764 pub const EXTENDED_SRGB_LINEAR: Self = Self(1000104002i32);
765 pub const DISPLAY_P3_LINEAR: Self = Self(1000104003i32);
766 pub const DCI_P3_NONLINEAR: Self = Self(1000104004i32);
767 pub const BT709_LINEAR: Self = Self(1000104005i32);
768 pub const BT709_NONLINEAR: Self = Self(1000104006i32);
769 pub const BT2020_LINEAR: Self = Self(1000104007i32);
770 pub const HDR10_ST2084: Self = Self(1000104008i32);
771 pub const DOLBYVISION: Self = Self(1000104009i32);
772 pub const HDR10_HLG: Self = Self(1000104010i32);
773 pub const ADOBERGB_LINEAR: Self = Self(1000104011i32);
774 pub const ADOBERGB_NONLINEAR: Self = Self(1000104012i32);
775 pub const PASS_THROUGH: Self = Self(1000104013i32);
776 pub const EXTENDED_SRGB_NONLINEAR: Self = Self(1000104014i32);
777 pub const DCI_P3_LINEAR: Self = Self::DISPLAY_P3_LINEAR;
778 pub const DISPLAY_NATIVE: Self = Self(1000213000i32);
779 #[inline]
780 pub const fn from_raw(value: i32) -> Self {
781 Self(value)
782 }
783 #[inline]
784 pub const fn as_raw(self) -> i32 {
785 self.0
786 }
787}
788impl core::fmt::Debug for ColorSpaceKHR {
789 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
790 match self.0 {
791 0i32 => f.write_str("SRGB_NONLINEAR"),
792 1000104001i32 => f.write_str("DISPLAY_P3_NONLINEAR"),
793 1000104002i32 => f.write_str("EXTENDED_SRGB_LINEAR"),
794 1000104003i32 => f.write_str("DISPLAY_P3_LINEAR"),
795 1000104004i32 => f.write_str("DCI_P3_NONLINEAR"),
796 1000104005i32 => f.write_str("BT709_LINEAR"),
797 1000104006i32 => f.write_str("BT709_NONLINEAR"),
798 1000104007i32 => f.write_str("BT2020_LINEAR"),
799 1000104008i32 => f.write_str("HDR10_ST2084"),
800 1000104009i32 => f.write_str("DOLBYVISION"),
801 1000104010i32 => f.write_str("HDR10_HLG"),
802 1000104011i32 => f.write_str("ADOBERGB_LINEAR"),
803 1000104012i32 => f.write_str("ADOBERGB_NONLINEAR"),
804 1000104013i32 => f.write_str("PASS_THROUGH"),
805 1000104014i32 => f.write_str("EXTENDED_SRGB_NONLINEAR"),
806 1000213000i32 => f.write_str("DISPLAY_NATIVE"),
807 other => write!(f, "{}({})", stringify!(ColorSpaceKHR), other),
808 }
809 }
810}
811#[repr(transparent)]
813#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
814#[doc(alias = "VkCommandBufferLevel")]
815pub struct CommandBufferLevel(i32);
816impl CommandBufferLevel {
817 pub const PRIMARY: Self = Self(0i32);
818 pub const SECONDARY: Self = Self(1i32);
819 #[inline]
820 pub const fn from_raw(value: i32) -> Self {
821 Self(value)
822 }
823 #[inline]
824 pub const fn as_raw(self) -> i32 {
825 self.0
826 }
827}
828impl core::fmt::Debug for CommandBufferLevel {
829 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
830 match self.0 {
831 0i32 => f.write_str("PRIMARY"),
832 1i32 => f.write_str("SECONDARY"),
833 other => write!(f, "{}({})", stringify!(CommandBufferLevel), other),
834 }
835 }
836}
837#[repr(transparent)]
839#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
840#[doc(alias = "VkCompareOp")]
841pub struct CompareOp(i32);
842impl CompareOp {
843 pub const NEVER: Self = Self(0i32);
844 pub const LESS: Self = Self(1i32);
845 pub const EQUAL: Self = Self(2i32);
846 pub const LESS_OR_EQUAL: Self = Self(3i32);
847 pub const GREATER: Self = Self(4i32);
848 pub const NOT_EQUAL: Self = Self(5i32);
849 pub const GREATER_OR_EQUAL: Self = Self(6i32);
850 pub const ALWAYS: Self = Self(7i32);
851 #[inline]
852 pub const fn from_raw(value: i32) -> Self {
853 Self(value)
854 }
855 #[inline]
856 pub const fn as_raw(self) -> i32 {
857 self.0
858 }
859}
860impl core::fmt::Debug for CompareOp {
861 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
862 match self.0 {
863 0i32 => f.write_str("NEVER"),
864 1i32 => f.write_str("LESS"),
865 2i32 => f.write_str("EQUAL"),
866 3i32 => f.write_str("LESS_OR_EQUAL"),
867 4i32 => f.write_str("GREATER"),
868 5i32 => f.write_str("NOT_EQUAL"),
869 6i32 => f.write_str("GREATER_OR_EQUAL"),
870 7i32 => f.write_str("ALWAYS"),
871 other => write!(f, "{}({})", stringify!(CompareOp), other),
872 }
873 }
874}
875#[repr(transparent)]
877#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
878#[doc(alias = "VkComponentSwizzle")]
879pub struct ComponentSwizzle(i32);
880impl ComponentSwizzle {
881 pub const IDENTITY: Self = Self(0i32);
882 pub const ZERO: Self = Self(1i32);
883 pub const ONE: Self = Self(2i32);
884 pub const R: Self = Self(3i32);
885 pub const G: Self = Self(4i32);
886 pub const B: Self = Self(5i32);
887 pub const A: Self = Self(6i32);
888 #[inline]
889 pub const fn from_raw(value: i32) -> Self {
890 Self(value)
891 }
892 #[inline]
893 pub const fn as_raw(self) -> i32 {
894 self.0
895 }
896}
897impl core::fmt::Debug for ComponentSwizzle {
898 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
899 match self.0 {
900 0i32 => f.write_str("IDENTITY"),
901 1i32 => f.write_str("ZERO"),
902 2i32 => f.write_str("ONE"),
903 3i32 => f.write_str("R"),
904 4i32 => f.write_str("G"),
905 5i32 => f.write_str("B"),
906 6i32 => f.write_str("A"),
907 other => write!(f, "{}({})", stringify!(ComponentSwizzle), other),
908 }
909 }
910}
911#[repr(transparent)]
913#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
914#[doc(alias = "VkComponentTypeKHR")]
915pub struct ComponentTypeKHR(i32);
916impl ComponentTypeKHR {
917 pub const FLOAT16: Self = Self(0i32);
918 pub const FLOAT32: Self = Self(1i32);
919 pub const FLOAT64: Self = Self(2i32);
920 pub const SINT8: Self = Self(3i32);
921 pub const SINT16: Self = Self(4i32);
922 pub const SINT32: Self = Self(5i32);
923 pub const SINT64: Self = Self(6i32);
924 pub const UINT8: Self = Self(7i32);
925 pub const UINT16: Self = Self(8i32);
926 pub const UINT32: Self = Self(9i32);
927 pub const UINT64: Self = Self(10i32);
928 pub const BFLOAT16: Self = Self(1000141000i32);
929 pub const SINT8_PACKED: Self = Self(1000491000i32);
930 pub const UINT8_PACKED: Self = Self(1000491001i32);
931 pub const FLOAT_E4M3: Self = Self::FLOAT8_E4M3;
932 pub const FLOAT_E5M2: Self = Self::FLOAT8_E5M2;
933 pub const FLOAT8_E4M3: Self = Self(1000491002i32);
934 pub const FLOAT8_E5M2: Self = Self(1000491003i32);
935 #[inline]
936 pub const fn from_raw(value: i32) -> Self {
937 Self(value)
938 }
939 #[inline]
940 pub const fn as_raw(self) -> i32 {
941 self.0
942 }
943}
944impl core::fmt::Debug for ComponentTypeKHR {
945 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
946 match self.0 {
947 0i32 => f.write_str("FLOAT16"),
948 1i32 => f.write_str("FLOAT32"),
949 2i32 => f.write_str("FLOAT64"),
950 3i32 => f.write_str("SINT8"),
951 4i32 => f.write_str("SINT16"),
952 5i32 => f.write_str("SINT32"),
953 6i32 => f.write_str("SINT64"),
954 7i32 => f.write_str("UINT8"),
955 8i32 => f.write_str("UINT16"),
956 9i32 => f.write_str("UINT32"),
957 10i32 => f.write_str("UINT64"),
958 1000141000i32 => f.write_str("BFLOAT16"),
959 1000491000i32 => f.write_str("SINT8_PACKED"),
960 1000491001i32 => f.write_str("UINT8_PACKED"),
961 1000491002i32 => f.write_str("FLOAT8_E4M3"),
962 1000491003i32 => f.write_str("FLOAT8_E5M2"),
963 other => write!(f, "{}({})", stringify!(ComponentTypeKHR), other),
964 }
965 }
966}
967#[repr(transparent)]
969#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
970#[doc(alias = "VkCompressedTriangleFormatAMDX")]
971pub struct CompressedTriangleFormatAMDX(i32);
972impl CompressedTriangleFormatAMDX {
973 pub const DGF1: Self = Self(0i32);
974 #[inline]
975 pub const fn from_raw(value: i32) -> Self {
976 Self(value)
977 }
978 #[inline]
979 pub const fn as_raw(self) -> i32 {
980 self.0
981 }
982}
983impl core::fmt::Debug for CompressedTriangleFormatAMDX {
984 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
985 match self.0 {
986 0i32 => f.write_str("DGF1"),
987 other => write!(f, "{}({})", stringify!(CompressedTriangleFormatAMDX), other),
988 }
989 }
990}
991#[repr(transparent)]
993#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
994#[doc(alias = "VkConservativeRasterizationModeEXT")]
995pub struct ConservativeRasterizationModeEXT(i32);
996impl ConservativeRasterizationModeEXT {
997 pub const DISABLED: Self = Self(0i32);
998 pub const OVERESTIMATE: Self = Self(1i32);
999 pub const UNDERESTIMATE: Self = Self(2i32);
1000 #[inline]
1001 pub const fn from_raw(value: i32) -> Self {
1002 Self(value)
1003 }
1004 #[inline]
1005 pub const fn as_raw(self) -> i32 {
1006 self.0
1007 }
1008}
1009impl core::fmt::Debug for ConservativeRasterizationModeEXT {
1010 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1011 match self.0 {
1012 0i32 => f.write_str("DISABLED"),
1013 1i32 => f.write_str("OVERESTIMATE"),
1014 2i32 => f.write_str("UNDERESTIMATE"),
1015 other => {
1016 write!(f, "{}({})", stringify!(ConservativeRasterizationModeEXT), other)
1017 }
1018 }
1019 }
1020}
1021#[repr(transparent)]
1023#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1024#[doc(alias = "VkCooperativeVectorMatrixLayoutNV")]
1025pub struct CooperativeVectorMatrixLayoutNV(i32);
1026impl CooperativeVectorMatrixLayoutNV {
1027 pub const ROW_MAJOR: Self = Self(0i32);
1028 pub const COLUMN_MAJOR: Self = Self(1i32);
1029 pub const INFERENCING_OPTIMAL: Self = Self(2i32);
1030 pub const TRAINING_OPTIMAL: Self = Self(3i32);
1031 #[inline]
1032 pub const fn from_raw(value: i32) -> Self {
1033 Self(value)
1034 }
1035 #[inline]
1036 pub const fn as_raw(self) -> i32 {
1037 self.0
1038 }
1039}
1040impl core::fmt::Debug for CooperativeVectorMatrixLayoutNV {
1041 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1042 match self.0 {
1043 0i32 => f.write_str("ROW_MAJOR"),
1044 1i32 => f.write_str("COLUMN_MAJOR"),
1045 2i32 => f.write_str("INFERENCING_OPTIMAL"),
1046 3i32 => f.write_str("TRAINING_OPTIMAL"),
1047 other => {
1048 write!(f, "{}({})", stringify!(CooperativeVectorMatrixLayoutNV), other)
1049 }
1050 }
1051 }
1052}
1053#[repr(transparent)]
1055#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1056#[doc(alias = "VkCopyAccelerationStructureModeKHR")]
1057pub struct CopyAccelerationStructureModeKHR(i32);
1058impl CopyAccelerationStructureModeKHR {
1059 pub const CLONE: Self = Self(0i32);
1060 pub const COMPACT: Self = Self(1i32);
1061 pub const SERIALIZE: Self = Self(2i32);
1062 pub const DESERIALIZE: Self = Self(3i32);
1063 #[inline]
1064 pub const fn from_raw(value: i32) -> Self {
1065 Self(value)
1066 }
1067 #[inline]
1068 pub const fn as_raw(self) -> i32 {
1069 self.0
1070 }
1071}
1072impl core::fmt::Debug for CopyAccelerationStructureModeKHR {
1073 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1074 match self.0 {
1075 0i32 => f.write_str("CLONE"),
1076 1i32 => f.write_str("COMPACT"),
1077 2i32 => f.write_str("SERIALIZE"),
1078 3i32 => f.write_str("DESERIALIZE"),
1079 other => {
1080 write!(f, "{}({})", stringify!(CopyAccelerationStructureModeKHR), other)
1081 }
1082 }
1083 }
1084}
1085#[repr(transparent)]
1087#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1088#[doc(alias = "VkCopyMicromapModeEXT")]
1089pub struct CopyMicromapModeEXT(i32);
1090impl CopyMicromapModeEXT {
1091 pub const CLONE: Self = Self(0i32);
1092 pub const SERIALIZE: Self = Self(1i32);
1093 pub const DESERIALIZE: Self = Self(2i32);
1094 pub const COMPACT: Self = Self(3i32);
1095 #[inline]
1096 pub const fn from_raw(value: i32) -> Self {
1097 Self(value)
1098 }
1099 #[inline]
1100 pub const fn as_raw(self) -> i32 {
1101 self.0
1102 }
1103}
1104impl core::fmt::Debug for CopyMicromapModeEXT {
1105 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1106 match self.0 {
1107 0i32 => f.write_str("CLONE"),
1108 1i32 => f.write_str("SERIALIZE"),
1109 2i32 => f.write_str("DESERIALIZE"),
1110 3i32 => f.write_str("COMPACT"),
1111 other => write!(f, "{}({})", stringify!(CopyMicromapModeEXT), other),
1112 }
1113 }
1114}
1115#[repr(transparent)]
1117#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1118#[doc(alias = "VkCoverageModulationModeNV")]
1119pub struct CoverageModulationModeNV(i32);
1120impl CoverageModulationModeNV {
1121 pub const NONE: Self = Self(0i32);
1122 pub const RGB: Self = Self(1i32);
1123 pub const ALPHA: Self = Self(2i32);
1124 pub const RGBA: Self = Self(3i32);
1125 #[inline]
1126 pub const fn from_raw(value: i32) -> Self {
1127 Self(value)
1128 }
1129 #[inline]
1130 pub const fn as_raw(self) -> i32 {
1131 self.0
1132 }
1133}
1134impl core::fmt::Debug for CoverageModulationModeNV {
1135 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1136 match self.0 {
1137 0i32 => f.write_str("NONE"),
1138 1i32 => f.write_str("RGB"),
1139 2i32 => f.write_str("ALPHA"),
1140 3i32 => f.write_str("RGBA"),
1141 other => write!(f, "{}({})", stringify!(CoverageModulationModeNV), other),
1142 }
1143 }
1144}
1145#[repr(transparent)]
1147#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1148#[doc(alias = "VkCoverageReductionModeNV")]
1149pub struct CoverageReductionModeNV(i32);
1150impl CoverageReductionModeNV {
1151 pub const MERGE: Self = Self(0i32);
1152 pub const TRUNCATE: Self = Self(1i32);
1153 #[inline]
1154 pub const fn from_raw(value: i32) -> Self {
1155 Self(value)
1156 }
1157 #[inline]
1158 pub const fn as_raw(self) -> i32 {
1159 self.0
1160 }
1161}
1162impl core::fmt::Debug for CoverageReductionModeNV {
1163 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1164 match self.0 {
1165 0i32 => f.write_str("MERGE"),
1166 1i32 => f.write_str("TRUNCATE"),
1167 other => write!(f, "{}({})", stringify!(CoverageReductionModeNV), other),
1168 }
1169 }
1170}
1171#[repr(transparent)]
1173#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1174#[doc(alias = "VkCubicFilterWeightsQCOM")]
1175pub struct CubicFilterWeightsQCOM(i32);
1176impl CubicFilterWeightsQCOM {
1177 pub const CATMULL_ROM: Self = Self(0i32);
1178 pub const ZERO_TANGENT_CARDINAL: Self = Self(1i32);
1179 pub const B_SPLINE: Self = Self(2i32);
1180 pub const MITCHELL_NETRAVALI: Self = Self(3i32);
1181 #[inline]
1182 pub const fn from_raw(value: i32) -> Self {
1183 Self(value)
1184 }
1185 #[inline]
1186 pub const fn as_raw(self) -> i32 {
1187 self.0
1188 }
1189}
1190impl core::fmt::Debug for CubicFilterWeightsQCOM {
1191 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1192 match self.0 {
1193 0i32 => f.write_str("CATMULL_ROM"),
1194 1i32 => f.write_str("ZERO_TANGENT_CARDINAL"),
1195 2i32 => f.write_str("B_SPLINE"),
1196 3i32 => f.write_str("MITCHELL_NETRAVALI"),
1197 other => write!(f, "{}({})", stringify!(CubicFilterWeightsQCOM), other),
1198 }
1199 }
1200}
1201#[repr(transparent)]
1203#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1204#[doc(alias = "VkDataGraphModelCacheTypeQCOM")]
1205pub struct DataGraphModelCacheTypeQCOM(i32);
1206impl DataGraphModelCacheTypeQCOM {
1207 pub const GENERIC_BINARY: Self = Self(0i32);
1208 #[inline]
1209 pub const fn from_raw(value: i32) -> Self {
1210 Self(value)
1211 }
1212 #[inline]
1213 pub const fn as_raw(self) -> i32 {
1214 self.0
1215 }
1216}
1217impl core::fmt::Debug for DataGraphModelCacheTypeQCOM {
1218 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1219 match self.0 {
1220 0i32 => f.write_str("GENERIC_BINARY"),
1221 other => write!(f, "{}({})", stringify!(DataGraphModelCacheTypeQCOM), other),
1222 }
1223 }
1224}
1225#[repr(transparent)]
1227#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1228#[doc(alias = "VkDataGraphPipelinePropertyARM")]
1229pub struct DataGraphPipelinePropertyARM(i32);
1230impl DataGraphPipelinePropertyARM {
1231 pub const CREATION_LOG: Self = Self(0i32);
1232 pub const IDENTIFIER: Self = Self(1i32);
1233 #[inline]
1234 pub const fn from_raw(value: i32) -> Self {
1235 Self(value)
1236 }
1237 #[inline]
1238 pub const fn as_raw(self) -> i32 {
1239 self.0
1240 }
1241}
1242impl core::fmt::Debug for DataGraphPipelinePropertyARM {
1243 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1244 match self.0 {
1245 0i32 => f.write_str("CREATION_LOG"),
1246 1i32 => f.write_str("IDENTIFIER"),
1247 other => write!(f, "{}({})", stringify!(DataGraphPipelinePropertyARM), other),
1248 }
1249 }
1250}
1251#[repr(transparent)]
1253#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1254#[doc(alias = "VkDataGraphPipelineSessionBindPointARM")]
1255pub struct DataGraphPipelineSessionBindPointARM(i32);
1256impl DataGraphPipelineSessionBindPointARM {
1257 pub const TRANSIENT: Self = Self(0i32);
1258 #[inline]
1259 pub const fn from_raw(value: i32) -> Self {
1260 Self(value)
1261 }
1262 #[inline]
1263 pub const fn as_raw(self) -> i32 {
1264 self.0
1265 }
1266}
1267impl core::fmt::Debug for DataGraphPipelineSessionBindPointARM {
1268 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1269 match self.0 {
1270 0i32 => f.write_str("TRANSIENT"),
1271 other => {
1272 write!(
1273 f, "{}({})", stringify!(DataGraphPipelineSessionBindPointARM), other
1274 )
1275 }
1276 }
1277 }
1278}
1279#[repr(transparent)]
1281#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1282#[doc(alias = "VkDataGraphPipelineSessionBindPointTypeARM")]
1283pub struct DataGraphPipelineSessionBindPointTypeARM(i32);
1284impl DataGraphPipelineSessionBindPointTypeARM {
1285 pub const MEMORY: Self = Self(0i32);
1286 #[inline]
1287 pub const fn from_raw(value: i32) -> Self {
1288 Self(value)
1289 }
1290 #[inline]
1291 pub const fn as_raw(self) -> i32 {
1292 self.0
1293 }
1294}
1295impl core::fmt::Debug for DataGraphPipelineSessionBindPointTypeARM {
1296 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1297 match self.0 {
1298 0i32 => f.write_str("MEMORY"),
1299 other => {
1300 write!(
1301 f, "{}({})", stringify!(DataGraphPipelineSessionBindPointTypeARM),
1302 other
1303 )
1304 }
1305 }
1306 }
1307}
1308#[repr(transparent)]
1310#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1311#[doc(alias = "VkDebugReportObjectTypeEXT")]
1312pub struct DebugReportObjectTypeEXT(i32);
1313impl DebugReportObjectTypeEXT {
1314 pub const UNKNOWN: Self = Self(0i32);
1315 pub const INSTANCE: Self = Self(1i32);
1316 pub const PHYSICAL_DEVICE: Self = Self(2i32);
1317 pub const DEVICE: Self = Self(3i32);
1318 pub const QUEUE: Self = Self(4i32);
1319 pub const SEMAPHORE: Self = Self(5i32);
1320 pub const COMMAND_BUFFER: Self = Self(6i32);
1321 pub const FENCE: Self = Self(7i32);
1322 pub const DEVICE_MEMORY: Self = Self(8i32);
1323 pub const BUFFER: Self = Self(9i32);
1324 pub const IMAGE: Self = Self(10i32);
1325 pub const EVENT: Self = Self(11i32);
1326 pub const QUERY_POOL: Self = Self(12i32);
1327 pub const BUFFER_VIEW: Self = Self(13i32);
1328 pub const IMAGE_VIEW: Self = Self(14i32);
1329 pub const SHADER_MODULE: Self = Self(15i32);
1330 pub const PIPELINE_CACHE: Self = Self(16i32);
1331 pub const PIPELINE_LAYOUT: Self = Self(17i32);
1332 pub const RENDER_PASS: Self = Self(18i32);
1333 pub const PIPELINE: Self = Self(19i32);
1334 pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20i32);
1335 pub const SAMPLER: Self = Self(21i32);
1336 pub const DESCRIPTOR_POOL: Self = Self(22i32);
1337 pub const DESCRIPTOR_SET: Self = Self(23i32);
1338 pub const FRAMEBUFFER: Self = Self(24i32);
1339 pub const COMMAND_POOL: Self = Self(25i32);
1340 pub const SURFACE_: Self = Self(26i32);
1341 pub const SWAPCHAIN_: Self = Self(27i32);
1342 pub const DEBUG_REPORT_CALLBACK_: Self = Self(28i32);
1343 pub const DEBUG_REPORT: Self = Self::DEBUG_REPORT_CALLBACK_;
1344 pub const DISPLAY_: Self = Self(29i32);
1345 pub const DISPLAY_MODE_: Self = Self(30i32);
1346 pub const VALIDATION_CACHE_: Self = Self(33i32);
1347 pub const VALIDATION_CACHE: Self = Self::VALIDATION_CACHE_;
1348 pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1000156000i32);
1349 pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1000085000i32);
1350 pub const CU_MODULE_: Self = Self(1000029000i32);
1351 pub const CU_FUNCTION_: Self = Self(1000029001i32);
1352 pub const DESCRIPTOR_UPDATE_TEMPLATE_: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE;
1353 pub const ACCELERATION_STRUCTURE_: Self = Self(1000150000i32);
1354 pub const SAMPLER_YCBCR_CONVERSION_: Self = Self::SAMPLER_YCBCR_CONVERSION;
1355 pub const CUDA_MODULE_: Self = Self(1000307000i32);
1356 pub const CUDA_FUNCTION_: Self = Self(1000307001i32);
1357 pub const BUFFER_COLLECTION_: Self = Self(1000366000i32);
1358 #[inline]
1359 pub const fn from_raw(value: i32) -> Self {
1360 Self(value)
1361 }
1362 #[inline]
1363 pub const fn as_raw(self) -> i32 {
1364 self.0
1365 }
1366}
1367impl core::fmt::Debug for DebugReportObjectTypeEXT {
1368 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1369 match self.0 {
1370 0i32 => f.write_str("UNKNOWN"),
1371 1i32 => f.write_str("INSTANCE"),
1372 2i32 => f.write_str("PHYSICAL_DEVICE"),
1373 3i32 => f.write_str("DEVICE"),
1374 4i32 => f.write_str("QUEUE"),
1375 5i32 => f.write_str("SEMAPHORE"),
1376 6i32 => f.write_str("COMMAND_BUFFER"),
1377 7i32 => f.write_str("FENCE"),
1378 8i32 => f.write_str("DEVICE_MEMORY"),
1379 9i32 => f.write_str("BUFFER"),
1380 10i32 => f.write_str("IMAGE"),
1381 11i32 => f.write_str("EVENT"),
1382 12i32 => f.write_str("QUERY_POOL"),
1383 13i32 => f.write_str("BUFFER_VIEW"),
1384 14i32 => f.write_str("IMAGE_VIEW"),
1385 15i32 => f.write_str("SHADER_MODULE"),
1386 16i32 => f.write_str("PIPELINE_CACHE"),
1387 17i32 => f.write_str("PIPELINE_LAYOUT"),
1388 18i32 => f.write_str("RENDER_PASS"),
1389 19i32 => f.write_str("PIPELINE"),
1390 20i32 => f.write_str("DESCRIPTOR_SET_LAYOUT"),
1391 21i32 => f.write_str("SAMPLER"),
1392 22i32 => f.write_str("DESCRIPTOR_POOL"),
1393 23i32 => f.write_str("DESCRIPTOR_SET"),
1394 24i32 => f.write_str("FRAMEBUFFER"),
1395 25i32 => f.write_str("COMMAND_POOL"),
1396 26i32 => f.write_str("SURFACE_"),
1397 27i32 => f.write_str("SWAPCHAIN_"),
1398 28i32 => f.write_str("DEBUG_REPORT_CALLBACK_"),
1399 29i32 => f.write_str("DISPLAY_"),
1400 30i32 => f.write_str("DISPLAY_MODE_"),
1401 33i32 => f.write_str("VALIDATION_CACHE_"),
1402 1000156000i32 => f.write_str("SAMPLER_YCBCR_CONVERSION"),
1403 1000085000i32 => f.write_str("DESCRIPTOR_UPDATE_TEMPLATE"),
1404 1000029000i32 => f.write_str("CU_MODULE_"),
1405 1000029001i32 => f.write_str("CU_FUNCTION_"),
1406 1000150000i32 => f.write_str("ACCELERATION_STRUCTURE_"),
1407 1000307000i32 => f.write_str("CUDA_MODULE_"),
1408 1000307001i32 => f.write_str("CUDA_FUNCTION_"),
1409 1000366000i32 => f.write_str("BUFFER_COLLECTION_"),
1410 other => write!(f, "{}({})", stringify!(DebugReportObjectTypeEXT), other),
1411 }
1412 }
1413}
1414#[repr(transparent)]
1416#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1417#[doc(alias = "VkDefaultVertexAttributeValueKHR")]
1418pub struct DefaultVertexAttributeValueKHR(i32);
1419impl DefaultVertexAttributeValueKHR {
1420 pub const ZERO_ZERO_ZERO_ZERO: Self = Self(0i32);
1421 pub const ZERO_ZERO_ZERO_ONE: Self = Self(1i32);
1422 #[inline]
1423 pub const fn from_raw(value: i32) -> Self {
1424 Self(value)
1425 }
1426 #[inline]
1427 pub const fn as_raw(self) -> i32 {
1428 self.0
1429 }
1430}
1431impl core::fmt::Debug for DefaultVertexAttributeValueKHR {
1432 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1433 match self.0 {
1434 0i32 => f.write_str("ZERO_ZERO_ZERO_ZERO"),
1435 1i32 => f.write_str("ZERO_ZERO_ZERO_ONE"),
1436 other => {
1437 write!(f, "{}({})", stringify!(DefaultVertexAttributeValueKHR), other)
1438 }
1439 }
1440 }
1441}
1442#[repr(transparent)]
1444#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1445#[doc(alias = "VkDepthBiasRepresentationEXT")]
1446pub struct DepthBiasRepresentationEXT(i32);
1447impl DepthBiasRepresentationEXT {
1448 pub const LEAST_REPRESENTABLE_VALUE_FORMAT: Self = Self(0i32);
1449 pub const LEAST_REPRESENTABLE_VALUE_FORCE_UNORM: Self = Self(1i32);
1450 pub const FLOAT: Self = Self(2i32);
1451 #[inline]
1452 pub const fn from_raw(value: i32) -> Self {
1453 Self(value)
1454 }
1455 #[inline]
1456 pub const fn as_raw(self) -> i32 {
1457 self.0
1458 }
1459}
1460impl core::fmt::Debug for DepthBiasRepresentationEXT {
1461 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1462 match self.0 {
1463 0i32 => f.write_str("LEAST_REPRESENTABLE_VALUE_FORMAT"),
1464 1i32 => f.write_str("LEAST_REPRESENTABLE_VALUE_FORCE_UNORM"),
1465 2i32 => f.write_str("FLOAT"),
1466 other => write!(f, "{}({})", stringify!(DepthBiasRepresentationEXT), other),
1467 }
1468 }
1469}
1470#[repr(transparent)]
1472#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1473#[doc(alias = "VkDepthClampModeEXT")]
1474pub struct DepthClampModeEXT(i32);
1475impl DepthClampModeEXT {
1476 pub const VIEWPORT_RANGE: Self = Self(0i32);
1477 pub const USER_DEFINED_RANGE: Self = Self(1i32);
1478 #[inline]
1479 pub const fn from_raw(value: i32) -> Self {
1480 Self(value)
1481 }
1482 #[inline]
1483 pub const fn as_raw(self) -> i32 {
1484 self.0
1485 }
1486}
1487impl core::fmt::Debug for DepthClampModeEXT {
1488 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1489 match self.0 {
1490 0i32 => f.write_str("VIEWPORT_RANGE"),
1491 1i32 => f.write_str("USER_DEFINED_RANGE"),
1492 other => write!(f, "{}({})", stringify!(DepthClampModeEXT), other),
1493 }
1494 }
1495}
1496#[repr(transparent)]
1498#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1499#[doc(alias = "VkDescriptorMappingSourceEXT")]
1500pub struct DescriptorMappingSourceEXT(i32);
1501impl DescriptorMappingSourceEXT {
1502 pub const HEAP_WITH_CONSTANT_OFFSET: Self = Self(0i32);
1503 pub const HEAP_WITH_PUSH_INDEX: Self = Self(1i32);
1504 pub const HEAP_WITH_INDIRECT_INDEX: Self = Self(2i32);
1505 pub const HEAP_WITH_INDIRECT_INDEX_ARRAY: Self = Self(3i32);
1506 pub const RESOURCE_HEAP_DATA: Self = Self(4i32);
1507 pub const PUSH_DATA: Self = Self(5i32);
1508 pub const PUSH_ADDRESS: Self = Self(6i32);
1509 pub const INDIRECT_ADDRESS: Self = Self(7i32);
1510 pub const HEAP_WITH_SHADER_RECORD_INDEX: Self = Self(8i32);
1511 pub const SHADER_RECORD_DATA: Self = Self(9i32);
1512 pub const SHADER_RECORD_ADDRESS: Self = Self(10i32);
1513 #[inline]
1514 pub const fn from_raw(value: i32) -> Self {
1515 Self(value)
1516 }
1517 #[inline]
1518 pub const fn as_raw(self) -> i32 {
1519 self.0
1520 }
1521}
1522impl core::fmt::Debug for DescriptorMappingSourceEXT {
1523 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1524 match self.0 {
1525 0i32 => f.write_str("HEAP_WITH_CONSTANT_OFFSET"),
1526 1i32 => f.write_str("HEAP_WITH_PUSH_INDEX"),
1527 2i32 => f.write_str("HEAP_WITH_INDIRECT_INDEX"),
1528 3i32 => f.write_str("HEAP_WITH_INDIRECT_INDEX_ARRAY"),
1529 4i32 => f.write_str("RESOURCE_HEAP_DATA"),
1530 5i32 => f.write_str("PUSH_DATA"),
1531 6i32 => f.write_str("PUSH_ADDRESS"),
1532 7i32 => f.write_str("INDIRECT_ADDRESS"),
1533 8i32 => f.write_str("HEAP_WITH_SHADER_RECORD_INDEX"),
1534 9i32 => f.write_str("SHADER_RECORD_DATA"),
1535 10i32 => f.write_str("SHADER_RECORD_ADDRESS"),
1536 other => write!(f, "{}({})", stringify!(DescriptorMappingSourceEXT), other),
1537 }
1538 }
1539}
1540#[repr(transparent)]
1542#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1543#[doc(alias = "VkDescriptorType")]
1544pub struct DescriptorType(i32);
1545impl DescriptorType {
1546 pub const SAMPLER: Self = Self(0i32);
1547 pub const COMBINED_IMAGE_SAMPLER: Self = Self(1i32);
1548 pub const SAMPLED_IMAGE: Self = Self(2i32);
1549 pub const STORAGE_IMAGE: Self = Self(3i32);
1550 pub const UNIFORM_TEXEL_BUFFER: Self = Self(4i32);
1551 pub const STORAGE_TEXEL_BUFFER: Self = Self(5i32);
1552 pub const UNIFORM_BUFFER: Self = Self(6i32);
1553 pub const STORAGE_BUFFER: Self = Self(7i32);
1554 pub const UNIFORM_BUFFER_DYNAMIC: Self = Self(8i32);
1555 pub const STORAGE_BUFFER_DYNAMIC: Self = Self(9i32);
1556 pub const INPUT_ATTACHMENT: Self = Self(10i32);
1557 pub const INLINE_UNIFORM_BLOCK: Self = Self(1000138000i32);
1558 pub const ACCELERATION_STRUCTURE: Self = Self(1000150000i32);
1559 pub const SAMPLE_WEIGHT_IMAGE: Self = Self(1000440000i32);
1560 pub const BLOCK_MATCH_IMAGE: Self = Self(1000440001i32);
1561 pub const TENSOR: Self = Self(1000460000i32);
1562 pub const PARTITIONED_ACCELERATION_STRUCTURE: Self = Self(1000570000i32);
1563 #[inline]
1564 pub const fn from_raw(value: i32) -> Self {
1565 Self(value)
1566 }
1567 #[inline]
1568 pub const fn as_raw(self) -> i32 {
1569 self.0
1570 }
1571}
1572impl core::fmt::Debug for DescriptorType {
1573 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1574 match self.0 {
1575 0i32 => f.write_str("SAMPLER"),
1576 1i32 => f.write_str("COMBINED_IMAGE_SAMPLER"),
1577 2i32 => f.write_str("SAMPLED_IMAGE"),
1578 3i32 => f.write_str("STORAGE_IMAGE"),
1579 4i32 => f.write_str("UNIFORM_TEXEL_BUFFER"),
1580 5i32 => f.write_str("STORAGE_TEXEL_BUFFER"),
1581 6i32 => f.write_str("UNIFORM_BUFFER"),
1582 7i32 => f.write_str("STORAGE_BUFFER"),
1583 8i32 => f.write_str("UNIFORM_BUFFER_DYNAMIC"),
1584 9i32 => f.write_str("STORAGE_BUFFER_DYNAMIC"),
1585 10i32 => f.write_str("INPUT_ATTACHMENT"),
1586 1000138000i32 => f.write_str("INLINE_UNIFORM_BLOCK"),
1587 1000150000i32 => f.write_str("ACCELERATION_STRUCTURE"),
1588 1000440000i32 => f.write_str("SAMPLE_WEIGHT_IMAGE"),
1589 1000440001i32 => f.write_str("BLOCK_MATCH_IMAGE"),
1590 1000460000i32 => f.write_str("TENSOR"),
1591 1000570000i32 => f.write_str("PARTITIONED_ACCELERATION_STRUCTURE"),
1592 other => write!(f, "{}({})", stringify!(DescriptorType), other),
1593 }
1594 }
1595}
1596#[repr(transparent)]
1598#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1599#[doc(alias = "VkDescriptorUpdateTemplateType")]
1600pub struct DescriptorUpdateTemplateType(i32);
1601impl DescriptorUpdateTemplateType {
1602 pub const DESCRIPTOR_SET: Self = Self(0i32);
1604 pub const PUSH_DESCRIPTORS: Self = Self(1i32);
1605 #[inline]
1606 pub const fn from_raw(value: i32) -> Self {
1607 Self(value)
1608 }
1609 #[inline]
1610 pub const fn as_raw(self) -> i32 {
1611 self.0
1612 }
1613}
1614impl core::fmt::Debug for DescriptorUpdateTemplateType {
1615 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1616 match self.0 {
1617 0i32 => f.write_str("DESCRIPTOR_SET"),
1618 1i32 => f.write_str("PUSH_DESCRIPTORS"),
1619 other => write!(f, "{}({})", stringify!(DescriptorUpdateTemplateType), other),
1620 }
1621 }
1622}
1623#[repr(transparent)]
1625#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1626#[doc(alias = "VkDeviceAddressBindingTypeEXT")]
1627pub struct DeviceAddressBindingTypeEXT(i32);
1628impl DeviceAddressBindingTypeEXT {
1629 pub const BIND: Self = Self(0i32);
1630 pub const UNBIND: Self = Self(1i32);
1631 #[inline]
1632 pub const fn from_raw(value: i32) -> Self {
1633 Self(value)
1634 }
1635 #[inline]
1636 pub const fn as_raw(self) -> i32 {
1637 self.0
1638 }
1639}
1640impl core::fmt::Debug for DeviceAddressBindingTypeEXT {
1641 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1642 match self.0 {
1643 0i32 => f.write_str("BIND"),
1644 1i32 => f.write_str("UNBIND"),
1645 other => write!(f, "{}({})", stringify!(DeviceAddressBindingTypeEXT), other),
1646 }
1647 }
1648}
1649#[repr(transparent)]
1651#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1652#[doc(alias = "VkDeviceEventTypeEXT")]
1653pub struct DeviceEventTypeEXT(i32);
1654impl DeviceEventTypeEXT {
1655 pub const DISPLAY_HOTPLUG: Self = Self(0i32);
1656 #[inline]
1657 pub const fn from_raw(value: i32) -> Self {
1658 Self(value)
1659 }
1660 #[inline]
1661 pub const fn as_raw(self) -> i32 {
1662 self.0
1663 }
1664}
1665impl core::fmt::Debug for DeviceEventTypeEXT {
1666 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1667 match self.0 {
1668 0i32 => f.write_str("DISPLAY_HOTPLUG"),
1669 other => write!(f, "{}({})", stringify!(DeviceEventTypeEXT), other),
1670 }
1671 }
1672}
1673#[repr(transparent)]
1675#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1676#[doc(alias = "VkDeviceFaultAddressTypeKHR")]
1677pub struct DeviceFaultAddressTypeKHR(i32);
1678impl DeviceFaultAddressTypeKHR {
1679 pub const NONE: Self = Self(0i32);
1681 pub const READ_INVALID: Self = Self(1i32);
1682 pub const WRITE_INVALID: Self = Self(2i32);
1683 pub const EXECUTE_INVALID: Self = Self(3i32);
1684 pub const INSTRUCTION_POINTER_UNKNOWN: Self = Self(4i32);
1685 pub const INSTRUCTION_POINTER_INVALID: Self = Self(5i32);
1686 pub const INSTRUCTION_POINTER_FAULT: Self = Self(6i32);
1687 #[inline]
1688 pub const fn from_raw(value: i32) -> Self {
1689 Self(value)
1690 }
1691 #[inline]
1692 pub const fn as_raw(self) -> i32 {
1693 self.0
1694 }
1695}
1696impl core::fmt::Debug for DeviceFaultAddressTypeKHR {
1697 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1698 match self.0 {
1699 0i32 => f.write_str("NONE"),
1700 1i32 => f.write_str("READ_INVALID"),
1701 2i32 => f.write_str("WRITE_INVALID"),
1702 3i32 => f.write_str("EXECUTE_INVALID"),
1703 4i32 => f.write_str("INSTRUCTION_POINTER_UNKNOWN"),
1704 5i32 => f.write_str("INSTRUCTION_POINTER_INVALID"),
1705 6i32 => f.write_str("INSTRUCTION_POINTER_FAULT"),
1706 other => write!(f, "{}({})", stringify!(DeviceFaultAddressTypeKHR), other),
1707 }
1708 }
1709}
1710#[repr(transparent)]
1712#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1713#[doc(alias = "VkDeviceFaultVendorBinaryHeaderVersionKHR")]
1714pub struct DeviceFaultVendorBinaryHeaderVersionKHR(i32);
1715impl DeviceFaultVendorBinaryHeaderVersionKHR {
1716 pub const ONE: Self = Self(1i32);
1717 #[inline]
1718 pub const fn from_raw(value: i32) -> Self {
1719 Self(value)
1720 }
1721 #[inline]
1722 pub const fn as_raw(self) -> i32 {
1723 self.0
1724 }
1725}
1726impl core::fmt::Debug for DeviceFaultVendorBinaryHeaderVersionKHR {
1727 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1728 match self.0 {
1729 1i32 => f.write_str("ONE"),
1730 other => {
1731 write!(
1732 f, "{}({})", stringify!(DeviceFaultVendorBinaryHeaderVersionKHR),
1733 other
1734 )
1735 }
1736 }
1737 }
1738}
1739#[repr(transparent)]
1741#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1742#[doc(alias = "VkDeviceMemoryReportEventTypeEXT")]
1743pub struct DeviceMemoryReportEventTypeEXT(i32);
1744impl DeviceMemoryReportEventTypeEXT {
1745 pub const ALLOCATE: Self = Self(0i32);
1746 pub const FREE: Self = Self(1i32);
1747 pub const IMPORT: Self = Self(2i32);
1748 pub const UNIMPORT: Self = Self(3i32);
1749 pub const ALLOCATION_FAILED: Self = Self(4i32);
1750 #[inline]
1751 pub const fn from_raw(value: i32) -> Self {
1752 Self(value)
1753 }
1754 #[inline]
1755 pub const fn as_raw(self) -> i32 {
1756 self.0
1757 }
1758}
1759impl core::fmt::Debug for DeviceMemoryReportEventTypeEXT {
1760 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1761 match self.0 {
1762 0i32 => f.write_str("ALLOCATE"),
1763 1i32 => f.write_str("FREE"),
1764 2i32 => f.write_str("IMPORT"),
1765 3i32 => f.write_str("UNIMPORT"),
1766 4i32 => f.write_str("ALLOCATION_FAILED"),
1767 other => {
1768 write!(f, "{}({})", stringify!(DeviceMemoryReportEventTypeEXT), other)
1769 }
1770 }
1771 }
1772}
1773#[repr(transparent)]
1775#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1776#[doc(alias = "VkDirectDriverLoadingModeLUNARG")]
1777pub struct DirectDriverLoadingModeLUNARG(i32);
1778impl DirectDriverLoadingModeLUNARG {
1779 pub const EXCLUSIVE: Self = Self(0i32);
1780 pub const INCLUSIVE: Self = Self(1i32);
1781 #[inline]
1782 pub const fn from_raw(value: i32) -> Self {
1783 Self(value)
1784 }
1785 #[inline]
1786 pub const fn as_raw(self) -> i32 {
1787 self.0
1788 }
1789}
1790impl core::fmt::Debug for DirectDriverLoadingModeLUNARG {
1791 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1792 match self.0 {
1793 0i32 => f.write_str("EXCLUSIVE"),
1794 1i32 => f.write_str("INCLUSIVE"),
1795 other => {
1796 write!(f, "{}({})", stringify!(DirectDriverLoadingModeLUNARG), other)
1797 }
1798 }
1799 }
1800}
1801#[repr(transparent)]
1803#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1804#[doc(alias = "VkDiscardRectangleModeEXT")]
1805pub struct DiscardRectangleModeEXT(i32);
1806impl DiscardRectangleModeEXT {
1807 pub const INCLUSIVE: Self = Self(0i32);
1808 pub const EXCLUSIVE: Self = Self(1i32);
1809 #[inline]
1810 pub const fn from_raw(value: i32) -> Self {
1811 Self(value)
1812 }
1813 #[inline]
1814 pub const fn as_raw(self) -> i32 {
1815 self.0
1816 }
1817}
1818impl core::fmt::Debug for DiscardRectangleModeEXT {
1819 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1820 match self.0 {
1821 0i32 => f.write_str("INCLUSIVE"),
1822 1i32 => f.write_str("EXCLUSIVE"),
1823 other => write!(f, "{}({})", stringify!(DiscardRectangleModeEXT), other),
1824 }
1825 }
1826}
1827#[repr(transparent)]
1829#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1830#[doc(alias = "VkDisplacementMicromapFormatNV")]
1831pub struct DisplacementMicromapFormatNV(i32);
1832impl DisplacementMicromapFormatNV {
1833 pub const _64_TRIANGLES_64_BYTES: Self = Self(1i32);
1834 pub const _256_TRIANGLES_128_BYTES: Self = Self(2i32);
1835 pub const _1024_TRIANGLES_128_BYTES: Self = Self(3i32);
1836 #[inline]
1837 pub const fn from_raw(value: i32) -> Self {
1838 Self(value)
1839 }
1840 #[inline]
1841 pub const fn as_raw(self) -> i32 {
1842 self.0
1843 }
1844}
1845impl core::fmt::Debug for DisplacementMicromapFormatNV {
1846 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1847 match self.0 {
1848 1i32 => f.write_str("_64_TRIANGLES_64_BYTES"),
1849 2i32 => f.write_str("_256_TRIANGLES_128_BYTES"),
1850 3i32 => f.write_str("_1024_TRIANGLES_128_BYTES"),
1851 other => write!(f, "{}({})", stringify!(DisplacementMicromapFormatNV), other),
1852 }
1853 }
1854}
1855#[repr(transparent)]
1857#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1858#[doc(alias = "VkDisplayEventTypeEXT")]
1859pub struct DisplayEventTypeEXT(i32);
1860impl DisplayEventTypeEXT {
1861 pub const FIRST_PIXEL_OUT: Self = Self(0i32);
1862 #[inline]
1863 pub const fn from_raw(value: i32) -> Self {
1864 Self(value)
1865 }
1866 #[inline]
1867 pub const fn as_raw(self) -> i32 {
1868 self.0
1869 }
1870}
1871impl core::fmt::Debug for DisplayEventTypeEXT {
1872 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1873 match self.0 {
1874 0i32 => f.write_str("FIRST_PIXEL_OUT"),
1875 other => write!(f, "{}({})", stringify!(DisplayEventTypeEXT), other),
1876 }
1877 }
1878}
1879#[repr(transparent)]
1881#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1882#[doc(alias = "VkDisplayPowerStateEXT")]
1883pub struct DisplayPowerStateEXT(i32);
1884impl DisplayPowerStateEXT {
1885 pub const OFF: Self = Self(0i32);
1886 pub const SUSPEND: Self = Self(1i32);
1887 pub const ON: Self = Self(2i32);
1888 #[inline]
1889 pub const fn from_raw(value: i32) -> Self {
1890 Self(value)
1891 }
1892 #[inline]
1893 pub const fn as_raw(self) -> i32 {
1894 self.0
1895 }
1896}
1897impl core::fmt::Debug for DisplayPowerStateEXT {
1898 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1899 match self.0 {
1900 0i32 => f.write_str("OFF"),
1901 1i32 => f.write_str("SUSPEND"),
1902 2i32 => f.write_str("ON"),
1903 other => write!(f, "{}({})", stringify!(DisplayPowerStateEXT), other),
1904 }
1905 }
1906}
1907#[repr(transparent)]
1909#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1910#[doc(alias = "VkDisplaySurfaceStereoTypeNV")]
1911pub struct DisplaySurfaceStereoTypeNV(i32);
1912impl DisplaySurfaceStereoTypeNV {
1913 pub const NONE: Self = Self(0i32);
1914 pub const ONBOARD_DIN: Self = Self(1i32);
1915 pub const HDMI_3D: Self = Self(2i32);
1916 pub const INBAND_DISPLAYPORT: Self = Self(3i32);
1917 #[inline]
1918 pub const fn from_raw(value: i32) -> Self {
1919 Self(value)
1920 }
1921 #[inline]
1922 pub const fn as_raw(self) -> i32 {
1923 self.0
1924 }
1925}
1926impl core::fmt::Debug for DisplaySurfaceStereoTypeNV {
1927 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1928 match self.0 {
1929 0i32 => f.write_str("NONE"),
1930 1i32 => f.write_str("ONBOARD_DIN"),
1931 2i32 => f.write_str("HDMI_3D"),
1932 3i32 => f.write_str("INBAND_DISPLAYPORT"),
1933 other => write!(f, "{}({})", stringify!(DisplaySurfaceStereoTypeNV), other),
1934 }
1935 }
1936}
1937#[repr(transparent)]
1939#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1940#[doc(alias = "VkDriverId")]
1941pub struct DriverId(i32);
1942impl DriverId {
1943 pub const AMD_PROPRIETARY: Self = Self(1i32);
1945 pub const AMD_OPEN_SOURCE: Self = Self(2i32);
1947 pub const MESA_RADV: Self = Self(3i32);
1949 pub const NVIDIA_PROPRIETARY: Self = Self(4i32);
1951 pub const INTEL_PROPRIETARY_WINDOWS: Self = Self(5i32);
1953 pub const INTEL_OPEN_SOURCE: Self = Self(6i32);
1955 pub const IMAGINATION_PROPRIETARY: Self = Self(7i32);
1957 pub const QUALCOMM_PROPRIETARY: Self = Self(8i32);
1959 pub const ARM_PROPRIETARY: Self = Self(9i32);
1961 pub const GOOGLE_SWIFTSHADER: Self = Self(10i32);
1963 pub const GGP_PROPRIETARY: Self = Self(11i32);
1965 pub const BROADCOM_PROPRIETARY: Self = Self(12i32);
1967 pub const MESA_LLVMPIPE: Self = Self(13i32);
1969 pub const MOLTENVK: Self = Self(14i32);
1971 pub const COREAVI_PROPRIETARY: Self = Self(15i32);
1973 pub const JUICE_PROPRIETARY: Self = Self(16i32);
1975 pub const VERISILICON_PROPRIETARY: Self = Self(17i32);
1977 pub const MESA_TURNIP: Self = Self(18i32);
1979 pub const MESA_V3DV: Self = Self(19i32);
1981 pub const MESA_PANVK: Self = Self(20i32);
1983 pub const SAMSUNG_PROPRIETARY: Self = Self(21i32);
1985 pub const MESA_VENUS: Self = Self(22i32);
1987 pub const MESA_DOZEN: Self = Self(23i32);
1989 pub const MESA_NVK: Self = Self(24i32);
1991 pub const IMAGINATION_OPEN_SOURCE: Self = Self(25i32);
1993 pub const MESA_HONEYKRISP: Self = Self(26i32);
1995 pub const VULKAN_SC_EMULATION_ON_VULKAN: Self = Self(27i32);
1997 pub const MESA_KOSMICKRISP: Self = Self(28i32);
1999 pub const INTEL_OPEN_SOURCE_: Self = Self::INTEL_OPEN_SOURCE;
2000 #[inline]
2001 pub const fn from_raw(value: i32) -> Self {
2002 Self(value)
2003 }
2004 #[inline]
2005 pub const fn as_raw(self) -> i32 {
2006 self.0
2007 }
2008}
2009impl core::fmt::Debug for DriverId {
2010 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2011 match self.0 {
2012 1i32 => f.write_str("AMD_PROPRIETARY"),
2013 2i32 => f.write_str("AMD_OPEN_SOURCE"),
2014 3i32 => f.write_str("MESA_RADV"),
2015 4i32 => f.write_str("NVIDIA_PROPRIETARY"),
2016 5i32 => f.write_str("INTEL_PROPRIETARY_WINDOWS"),
2017 6i32 => f.write_str("INTEL_OPEN_SOURCE"),
2018 7i32 => f.write_str("IMAGINATION_PROPRIETARY"),
2019 8i32 => f.write_str("QUALCOMM_PROPRIETARY"),
2020 9i32 => f.write_str("ARM_PROPRIETARY"),
2021 10i32 => f.write_str("GOOGLE_SWIFTSHADER"),
2022 11i32 => f.write_str("GGP_PROPRIETARY"),
2023 12i32 => f.write_str("BROADCOM_PROPRIETARY"),
2024 13i32 => f.write_str("MESA_LLVMPIPE"),
2025 14i32 => f.write_str("MOLTENVK"),
2026 15i32 => f.write_str("COREAVI_PROPRIETARY"),
2027 16i32 => f.write_str("JUICE_PROPRIETARY"),
2028 17i32 => f.write_str("VERISILICON_PROPRIETARY"),
2029 18i32 => f.write_str("MESA_TURNIP"),
2030 19i32 => f.write_str("MESA_V3DV"),
2031 20i32 => f.write_str("MESA_PANVK"),
2032 21i32 => f.write_str("SAMSUNG_PROPRIETARY"),
2033 22i32 => f.write_str("MESA_VENUS"),
2034 23i32 => f.write_str("MESA_DOZEN"),
2035 24i32 => f.write_str("MESA_NVK"),
2036 25i32 => f.write_str("IMAGINATION_OPEN_SOURCE"),
2037 26i32 => f.write_str("MESA_HONEYKRISP"),
2038 27i32 => f.write_str("VULKAN_SC_EMULATION_ON_VULKAN"),
2039 28i32 => f.write_str("MESA_KOSMICKRISP"),
2040 other => write!(f, "{}({})", stringify!(DriverId), other),
2041 }
2042 }
2043}
2044#[repr(transparent)]
2046#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2047#[doc(alias = "VkDynamicState")]
2048pub struct DynamicState(i32);
2049impl DynamicState {
2050 pub const VIEWPORT: Self = Self(0i32);
2051 pub const SCISSOR: Self = Self(1i32);
2052 pub const LINE_WIDTH: Self = Self(2i32);
2053 pub const DEPTH_BIAS: Self = Self(3i32);
2054 pub const BLEND_CONSTANTS: Self = Self(4i32);
2055 pub const DEPTH_BOUNDS: Self = Self(5i32);
2056 pub const STENCIL_COMPARE_MASK: Self = Self(6i32);
2057 pub const STENCIL_WRITE_MASK: Self = Self(7i32);
2058 pub const STENCIL_REFERENCE: Self = Self(8i32);
2059 pub const CULL_MODE: Self = Self(1000267000i32);
2060 pub const FRONT_FACE: Self = Self(1000267001i32);
2061 pub const PRIMITIVE_TOPOLOGY: Self = Self(1000267002i32);
2062 pub const VIEWPORT_WITH_COUNT: Self = Self(1000267003i32);
2063 pub const SCISSOR_WITH_COUNT: Self = Self(1000267004i32);
2064 pub const VERTEX_INPUT_BINDING_STRIDE: Self = Self(1000267005i32);
2065 pub const DEPTH_TEST_ENABLE: Self = Self(1000267006i32);
2066 pub const DEPTH_WRITE_ENABLE: Self = Self(1000267007i32);
2067 pub const DEPTH_COMPARE_OP: Self = Self(1000267008i32);
2068 pub const DEPTH_BOUNDS_TEST_ENABLE: Self = Self(1000267009i32);
2069 pub const STENCIL_TEST_ENABLE: Self = Self(1000267010i32);
2070 pub const STENCIL_OP: Self = Self(1000267011i32);
2071 pub const RASTERIZER_DISCARD_ENABLE: Self = Self(1000377001i32);
2072 pub const DEPTH_BIAS_ENABLE: Self = Self(1000377002i32);
2073 pub const PRIMITIVE_RESTART_ENABLE: Self = Self(1000377004i32);
2074 pub const LINE_STIPPLE: Self = Self(1000259000i32);
2075 pub const VIEWPORT_W_SCALING: Self = Self(1000087000i32);
2076 pub const DISCARD_RECTANGLE: Self = Self(1000099000i32);
2077 pub const DISCARD_RECTANGLE_ENABLE: Self = Self(1000099001i32);
2078 pub const DISCARD_RECTANGLE_MODE: Self = Self(1000099002i32);
2079 pub const SAMPLE_LOCATIONS: Self = Self(1000143000i32);
2080 pub const RAY_TRACING_PIPELINE_STACK_SIZE: Self = Self(1000347000i32);
2081 pub const VIEWPORT_SHADING_RATE_PALETTE: Self = Self(1000164004i32);
2082 pub const VIEWPORT_COARSE_SAMPLE_ORDER: Self = Self(1000164006i32);
2083 pub const EXCLUSIVE_SCISSOR_ENABLE: Self = Self(1000205000i32);
2084 pub const EXCLUSIVE_SCISSOR: Self = Self(1000205001i32);
2085 pub const FRAGMENT_SHADING_RATE: Self = Self(1000226000i32);
2086 pub const VERTEX_INPUT: Self = Self(1000352000i32);
2087 pub const PATCH_CONTROL_POINTS: Self = Self(1000377000i32);
2089 pub const LOGIC_OP: Self = Self(1000377003i32);
2091 pub const COLOR_WRITE_ENABLE: Self = Self(1000381000i32);
2092 pub const DEPTH_CLAMP_ENABLE: Self = Self(1000455003i32);
2093 pub const POLYGON_MODE: Self = Self(1000455004i32);
2094 pub const RASTERIZATION_SAMPLES: Self = Self(1000455005i32);
2095 pub const SAMPLE_MASK: Self = Self(1000455006i32);
2096 pub const ALPHA_TO_COVERAGE_ENABLE: Self = Self(1000455007i32);
2097 pub const ALPHA_TO_ONE_ENABLE: Self = Self(1000455008i32);
2098 pub const LOGIC_OP_ENABLE: Self = Self(1000455009i32);
2099 pub const COLOR_BLEND_ENABLE: Self = Self(1000455010i32);
2100 pub const COLOR_BLEND_EQUATION: Self = Self(1000455011i32);
2101 pub const COLOR_WRITE_MASK: Self = Self(1000455012i32);
2102 pub const TESSELLATION_DOMAIN_ORIGIN: Self = Self(1000455002i32);
2103 pub const RASTERIZATION_STREAM: Self = Self(1000455013i32);
2104 pub const CONSERVATIVE_RASTERIZATION_MODE: Self = Self(1000455014i32);
2105 pub const EXTRA_PRIMITIVE_OVERESTIMATION_SIZE: Self = Self(1000455015i32);
2106 pub const DEPTH_CLIP_ENABLE: Self = Self(1000455016i32);
2107 pub const SAMPLE_LOCATIONS_ENABLE: Self = Self(1000455017i32);
2108 pub const COLOR_BLEND_ADVANCED: Self = Self(1000455018i32);
2109 pub const PROVOKING_VERTEX_MODE: Self = Self(1000455019i32);
2110 pub const LINE_RASTERIZATION_MODE: Self = Self(1000455020i32);
2111 pub const LINE_STIPPLE_ENABLE: Self = Self(1000455021i32);
2112 pub const DEPTH_CLIP_NEGATIVE_ONE_TO_ONE: Self = Self(1000455022i32);
2113 pub const VIEWPORT_W_SCALING_ENABLE: Self = Self(1000455023i32);
2114 pub const VIEWPORT_SWIZZLE: Self = Self(1000455024i32);
2115 pub const COVERAGE_TO_COLOR_ENABLE: Self = Self(1000455025i32);
2116 pub const COVERAGE_TO_COLOR_LOCATION: Self = Self(1000455026i32);
2117 pub const COVERAGE_MODULATION_MODE: Self = Self(1000455027i32);
2118 pub const COVERAGE_MODULATION_TABLE_ENABLE: Self = Self(1000455028i32);
2119 pub const COVERAGE_MODULATION_TABLE: Self = Self(1000455029i32);
2120 pub const SHADING_RATE_IMAGE_ENABLE: Self = Self(1000455030i32);
2121 pub const REPRESENTATIVE_FRAGMENT_TEST_ENABLE: Self = Self(1000455031i32);
2122 pub const COVERAGE_REDUCTION_MODE: Self = Self(1000455032i32);
2123 pub const ATTACHMENT_FEEDBACK_LOOP_ENABLE: Self = Self(1000524000i32);
2124 pub const DEPTH_CLAMP_RANGE: Self = Self(1000582000i32);
2125 #[inline]
2126 pub const fn from_raw(value: i32) -> Self {
2127 Self(value)
2128 }
2129 #[inline]
2130 pub const fn as_raw(self) -> i32 {
2131 self.0
2132 }
2133}
2134impl core::fmt::Debug for DynamicState {
2135 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2136 match self.0 {
2137 0i32 => f.write_str("VIEWPORT"),
2138 1i32 => f.write_str("SCISSOR"),
2139 2i32 => f.write_str("LINE_WIDTH"),
2140 3i32 => f.write_str("DEPTH_BIAS"),
2141 4i32 => f.write_str("BLEND_CONSTANTS"),
2142 5i32 => f.write_str("DEPTH_BOUNDS"),
2143 6i32 => f.write_str("STENCIL_COMPARE_MASK"),
2144 7i32 => f.write_str("STENCIL_WRITE_MASK"),
2145 8i32 => f.write_str("STENCIL_REFERENCE"),
2146 1000267000i32 => f.write_str("CULL_MODE"),
2147 1000267001i32 => f.write_str("FRONT_FACE"),
2148 1000267002i32 => f.write_str("PRIMITIVE_TOPOLOGY"),
2149 1000267003i32 => f.write_str("VIEWPORT_WITH_COUNT"),
2150 1000267004i32 => f.write_str("SCISSOR_WITH_COUNT"),
2151 1000267005i32 => f.write_str("VERTEX_INPUT_BINDING_STRIDE"),
2152 1000267006i32 => f.write_str("DEPTH_TEST_ENABLE"),
2153 1000267007i32 => f.write_str("DEPTH_WRITE_ENABLE"),
2154 1000267008i32 => f.write_str("DEPTH_COMPARE_OP"),
2155 1000267009i32 => f.write_str("DEPTH_BOUNDS_TEST_ENABLE"),
2156 1000267010i32 => f.write_str("STENCIL_TEST_ENABLE"),
2157 1000267011i32 => f.write_str("STENCIL_OP"),
2158 1000377001i32 => f.write_str("RASTERIZER_DISCARD_ENABLE"),
2159 1000377002i32 => f.write_str("DEPTH_BIAS_ENABLE"),
2160 1000377004i32 => f.write_str("PRIMITIVE_RESTART_ENABLE"),
2161 1000259000i32 => f.write_str("LINE_STIPPLE"),
2162 1000087000i32 => f.write_str("VIEWPORT_W_SCALING"),
2163 1000099000i32 => f.write_str("DISCARD_RECTANGLE"),
2164 1000099001i32 => f.write_str("DISCARD_RECTANGLE_ENABLE"),
2165 1000099002i32 => f.write_str("DISCARD_RECTANGLE_MODE"),
2166 1000143000i32 => f.write_str("SAMPLE_LOCATIONS"),
2167 1000347000i32 => f.write_str("RAY_TRACING_PIPELINE_STACK_SIZE"),
2168 1000164004i32 => f.write_str("VIEWPORT_SHADING_RATE_PALETTE"),
2169 1000164006i32 => f.write_str("VIEWPORT_COARSE_SAMPLE_ORDER"),
2170 1000205000i32 => f.write_str("EXCLUSIVE_SCISSOR_ENABLE"),
2171 1000205001i32 => f.write_str("EXCLUSIVE_SCISSOR"),
2172 1000226000i32 => f.write_str("FRAGMENT_SHADING_RATE"),
2173 1000352000i32 => f.write_str("VERTEX_INPUT"),
2174 1000377000i32 => f.write_str("PATCH_CONTROL_POINTS"),
2175 1000377003i32 => f.write_str("LOGIC_OP"),
2176 1000381000i32 => f.write_str("COLOR_WRITE_ENABLE"),
2177 1000455003i32 => f.write_str("DEPTH_CLAMP_ENABLE"),
2178 1000455004i32 => f.write_str("POLYGON_MODE"),
2179 1000455005i32 => f.write_str("RASTERIZATION_SAMPLES"),
2180 1000455006i32 => f.write_str("SAMPLE_MASK"),
2181 1000455007i32 => f.write_str("ALPHA_TO_COVERAGE_ENABLE"),
2182 1000455008i32 => f.write_str("ALPHA_TO_ONE_ENABLE"),
2183 1000455009i32 => f.write_str("LOGIC_OP_ENABLE"),
2184 1000455010i32 => f.write_str("COLOR_BLEND_ENABLE"),
2185 1000455011i32 => f.write_str("COLOR_BLEND_EQUATION"),
2186 1000455012i32 => f.write_str("COLOR_WRITE_MASK"),
2187 1000455002i32 => f.write_str("TESSELLATION_DOMAIN_ORIGIN"),
2188 1000455013i32 => f.write_str("RASTERIZATION_STREAM"),
2189 1000455014i32 => f.write_str("CONSERVATIVE_RASTERIZATION_MODE"),
2190 1000455015i32 => f.write_str("EXTRA_PRIMITIVE_OVERESTIMATION_SIZE"),
2191 1000455016i32 => f.write_str("DEPTH_CLIP_ENABLE"),
2192 1000455017i32 => f.write_str("SAMPLE_LOCATIONS_ENABLE"),
2193 1000455018i32 => f.write_str("COLOR_BLEND_ADVANCED"),
2194 1000455019i32 => f.write_str("PROVOKING_VERTEX_MODE"),
2195 1000455020i32 => f.write_str("LINE_RASTERIZATION_MODE"),
2196 1000455021i32 => f.write_str("LINE_STIPPLE_ENABLE"),
2197 1000455022i32 => f.write_str("DEPTH_CLIP_NEGATIVE_ONE_TO_ONE"),
2198 1000455023i32 => f.write_str("VIEWPORT_W_SCALING_ENABLE"),
2199 1000455024i32 => f.write_str("VIEWPORT_SWIZZLE"),
2200 1000455025i32 => f.write_str("COVERAGE_TO_COLOR_ENABLE"),
2201 1000455026i32 => f.write_str("COVERAGE_TO_COLOR_LOCATION"),
2202 1000455027i32 => f.write_str("COVERAGE_MODULATION_MODE"),
2203 1000455028i32 => f.write_str("COVERAGE_MODULATION_TABLE_ENABLE"),
2204 1000455029i32 => f.write_str("COVERAGE_MODULATION_TABLE"),
2205 1000455030i32 => f.write_str("SHADING_RATE_IMAGE_ENABLE"),
2206 1000455031i32 => f.write_str("REPRESENTATIVE_FRAGMENT_TEST_ENABLE"),
2207 1000455032i32 => f.write_str("COVERAGE_REDUCTION_MODE"),
2208 1000524000i32 => f.write_str("ATTACHMENT_FEEDBACK_LOOP_ENABLE"),
2209 1000582000i32 => f.write_str("DEPTH_CLAMP_RANGE"),
2210 other => write!(f, "{}({})", stringify!(DynamicState), other),
2211 }
2212 }
2213}
2214#[repr(transparent)]
2216#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2217#[doc(alias = "VkFaultLevel")]
2218pub struct FaultLevel(i32);
2219impl FaultLevel {
2220 pub const UNASSIGNED: Self = Self(0i32);
2221 pub const CRITICAL: Self = Self(1i32);
2222 pub const RECOVERABLE: Self = Self(2i32);
2223 pub const WARNING: Self = Self(3i32);
2224 #[inline]
2225 pub const fn from_raw(value: i32) -> Self {
2226 Self(value)
2227 }
2228 #[inline]
2229 pub const fn as_raw(self) -> i32 {
2230 self.0
2231 }
2232}
2233impl core::fmt::Debug for FaultLevel {
2234 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2235 match self.0 {
2236 0i32 => f.write_str("UNASSIGNED"),
2237 1i32 => f.write_str("CRITICAL"),
2238 2i32 => f.write_str("RECOVERABLE"),
2239 3i32 => f.write_str("WARNING"),
2240 other => write!(f, "{}({})", stringify!(FaultLevel), other),
2241 }
2242 }
2243}
2244#[repr(transparent)]
2246#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2247#[doc(alias = "VkFaultQueryBehavior")]
2248pub struct FaultQueryBehavior(i32);
2249impl FaultQueryBehavior {
2250 pub const GET_AND_CLEAR_ALL_FAULTS: Self = Self(0i32);
2251 #[inline]
2252 pub const fn from_raw(value: i32) -> Self {
2253 Self(value)
2254 }
2255 #[inline]
2256 pub const fn as_raw(self) -> i32 {
2257 self.0
2258 }
2259}
2260impl core::fmt::Debug for FaultQueryBehavior {
2261 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2262 match self.0 {
2263 0i32 => f.write_str("GET_AND_CLEAR_ALL_FAULTS"),
2264 other => write!(f, "{}({})", stringify!(FaultQueryBehavior), other),
2265 }
2266 }
2267}
2268#[repr(transparent)]
2270#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2271#[doc(alias = "VkFaultType")]
2272pub struct FaultType(i32);
2273impl FaultType {
2274 pub const INVALID: Self = Self(0i32);
2275 pub const UNASSIGNED: Self = Self(1i32);
2276 pub const IMPLEMENTATION: Self = Self(2i32);
2277 pub const SYSTEM: Self = Self(3i32);
2278 pub const PHYSICAL_DEVICE: Self = Self(4i32);
2279 pub const COMMAND_BUFFER_FULL: Self = Self(5i32);
2280 pub const INVALID_API_USAGE: Self = Self(6i32);
2281 #[inline]
2282 pub const fn from_raw(value: i32) -> Self {
2283 Self(value)
2284 }
2285 #[inline]
2286 pub const fn as_raw(self) -> i32 {
2287 self.0
2288 }
2289}
2290impl core::fmt::Debug for FaultType {
2291 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2292 match self.0 {
2293 0i32 => f.write_str("INVALID"),
2294 1i32 => f.write_str("UNASSIGNED"),
2295 2i32 => f.write_str("IMPLEMENTATION"),
2296 3i32 => f.write_str("SYSTEM"),
2297 4i32 => f.write_str("PHYSICAL_DEVICE"),
2298 5i32 => f.write_str("COMMAND_BUFFER_FULL"),
2299 6i32 => f.write_str("INVALID_API_USAGE"),
2300 other => write!(f, "{}({})", stringify!(FaultType), other),
2301 }
2302 }
2303}
2304#[repr(transparent)]
2306#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2307#[doc(alias = "VkFilter")]
2308pub struct Filter(i32);
2309impl Filter {
2310 pub const NEAREST: Self = Self(0i32);
2311 pub const LINEAR: Self = Self(1i32);
2312 #[inline]
2313 pub const fn from_raw(value: i32) -> Self {
2314 Self(value)
2315 }
2316 #[inline]
2317 pub const fn as_raw(self) -> i32 {
2318 self.0
2319 }
2320}
2321impl core::fmt::Debug for Filter {
2322 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2323 match self.0 {
2324 0i32 => f.write_str("NEAREST"),
2325 1i32 => f.write_str("LINEAR"),
2326 other => write!(f, "{}({})", stringify!(Filter), other),
2327 }
2328 }
2329}
2330#[repr(transparent)]
2332#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2333#[doc(alias = "VkFormat")]
2334pub struct Format(i32);
2335impl Format {
2336 pub const UNDEFINED: Self = Self(0i32);
2337 pub const R4G4_UNORM_PACK8: Self = Self(1i32);
2338 pub const R4G4B4A4_UNORM_PACK16: Self = Self(2i32);
2339 pub const B4G4R4A4_UNORM_PACK16: Self = Self(3i32);
2340 pub const R5G6B5_UNORM_PACK16: Self = Self(4i32);
2341 pub const B5G6R5_UNORM_PACK16: Self = Self(5i32);
2342 pub const R5G5B5A1_UNORM_PACK16: Self = Self(6i32);
2343 pub const B5G5R5A1_UNORM_PACK16: Self = Self(7i32);
2344 pub const A1R5G5B5_UNORM_PACK16: Self = Self(8i32);
2345 pub const R8_UNORM: Self = Self(9i32);
2346 pub const R8_SNORM: Self = Self(10i32);
2347 pub const R8_USCALED: Self = Self(11i32);
2348 pub const R8_SSCALED: Self = Self(12i32);
2349 pub const R8_UINT: Self = Self(13i32);
2350 pub const R8_SINT: Self = Self(14i32);
2351 pub const R8_SRGB: Self = Self(15i32);
2352 pub const R8G8_UNORM: Self = Self(16i32);
2353 pub const R8G8_SNORM: Self = Self(17i32);
2354 pub const R8G8_USCALED: Self = Self(18i32);
2355 pub const R8G8_SSCALED: Self = Self(19i32);
2356 pub const R8G8_UINT: Self = Self(20i32);
2357 pub const R8G8_SINT: Self = Self(21i32);
2358 pub const R8G8_SRGB: Self = Self(22i32);
2359 pub const R8G8B8_UNORM: Self = Self(23i32);
2360 pub const R8G8B8_SNORM: Self = Self(24i32);
2361 pub const R8G8B8_USCALED: Self = Self(25i32);
2362 pub const R8G8B8_SSCALED: Self = Self(26i32);
2363 pub const R8G8B8_UINT: Self = Self(27i32);
2364 pub const R8G8B8_SINT: Self = Self(28i32);
2365 pub const R8G8B8_SRGB: Self = Self(29i32);
2366 pub const B8G8R8_UNORM: Self = Self(30i32);
2367 pub const B8G8R8_SNORM: Self = Self(31i32);
2368 pub const B8G8R8_USCALED: Self = Self(32i32);
2369 pub const B8G8R8_SSCALED: Self = Self(33i32);
2370 pub const B8G8R8_UINT: Self = Self(34i32);
2371 pub const B8G8R8_SINT: Self = Self(35i32);
2372 pub const B8G8R8_SRGB: Self = Self(36i32);
2373 pub const R8G8B8A8_UNORM: Self = Self(37i32);
2374 pub const R8G8B8A8_SNORM: Self = Self(38i32);
2375 pub const R8G8B8A8_USCALED: Self = Self(39i32);
2376 pub const R8G8B8A8_SSCALED: Self = Self(40i32);
2377 pub const R8G8B8A8_UINT: Self = Self(41i32);
2378 pub const R8G8B8A8_SINT: Self = Self(42i32);
2379 pub const R8G8B8A8_SRGB: Self = Self(43i32);
2380 pub const B8G8R8A8_UNORM: Self = Self(44i32);
2381 pub const B8G8R8A8_SNORM: Self = Self(45i32);
2382 pub const B8G8R8A8_USCALED: Self = Self(46i32);
2383 pub const B8G8R8A8_SSCALED: Self = Self(47i32);
2384 pub const B8G8R8A8_UINT: Self = Self(48i32);
2385 pub const B8G8R8A8_SINT: Self = Self(49i32);
2386 pub const B8G8R8A8_SRGB: Self = Self(50i32);
2387 pub const A8B8G8R8_UNORM_PACK32: Self = Self(51i32);
2388 pub const A8B8G8R8_SNORM_PACK32: Self = Self(52i32);
2389 pub const A8B8G8R8_USCALED_PACK32: Self = Self(53i32);
2390 pub const A8B8G8R8_SSCALED_PACK32: Self = Self(54i32);
2391 pub const A8B8G8R8_UINT_PACK32: Self = Self(55i32);
2392 pub const A8B8G8R8_SINT_PACK32: Self = Self(56i32);
2393 pub const A8B8G8R8_SRGB_PACK32: Self = Self(57i32);
2394 pub const A2R10G10B10_UNORM_PACK32: Self = Self(58i32);
2395 pub const A2R10G10B10_SNORM_PACK32: Self = Self(59i32);
2396 pub const A2R10G10B10_USCALED_PACK32: Self = Self(60i32);
2397 pub const A2R10G10B10_SSCALED_PACK32: Self = Self(61i32);
2398 pub const A2R10G10B10_UINT_PACK32: Self = Self(62i32);
2399 pub const A2R10G10B10_SINT_PACK32: Self = Self(63i32);
2400 pub const A2B10G10R10_UNORM_PACK32: Self = Self(64i32);
2401 pub const A2B10G10R10_SNORM_PACK32: Self = Self(65i32);
2402 pub const A2B10G10R10_USCALED_PACK32: Self = Self(66i32);
2403 pub const A2B10G10R10_SSCALED_PACK32: Self = Self(67i32);
2404 pub const A2B10G10R10_UINT_PACK32: Self = Self(68i32);
2405 pub const A2B10G10R10_SINT_PACK32: Self = Self(69i32);
2406 pub const R16_UNORM: Self = Self(70i32);
2407 pub const R16_SNORM: Self = Self(71i32);
2408 pub const R16_USCALED: Self = Self(72i32);
2409 pub const R16_SSCALED: Self = Self(73i32);
2410 pub const R16_UINT: Self = Self(74i32);
2411 pub const R16_SINT: Self = Self(75i32);
2412 pub const R16_SFLOAT: Self = Self(76i32);
2413 pub const R16G16_UNORM: Self = Self(77i32);
2414 pub const R16G16_SNORM: Self = Self(78i32);
2415 pub const R16G16_USCALED: Self = Self(79i32);
2416 pub const R16G16_SSCALED: Self = Self(80i32);
2417 pub const R16G16_UINT: Self = Self(81i32);
2418 pub const R16G16_SINT: Self = Self(82i32);
2419 pub const R16G16_SFLOAT: Self = Self(83i32);
2420 pub const R16G16B16_UNORM: Self = Self(84i32);
2421 pub const R16G16B16_SNORM: Self = Self(85i32);
2422 pub const R16G16B16_USCALED: Self = Self(86i32);
2423 pub const R16G16B16_SSCALED: Self = Self(87i32);
2424 pub const R16G16B16_UINT: Self = Self(88i32);
2425 pub const R16G16B16_SINT: Self = Self(89i32);
2426 pub const R16G16B16_SFLOAT: Self = Self(90i32);
2427 pub const R16G16B16A16_UNORM: Self = Self(91i32);
2428 pub const R16G16B16A16_SNORM: Self = Self(92i32);
2429 pub const R16G16B16A16_USCALED: Self = Self(93i32);
2430 pub const R16G16B16A16_SSCALED: Self = Self(94i32);
2431 pub const R16G16B16A16_UINT: Self = Self(95i32);
2432 pub const R16G16B16A16_SINT: Self = Self(96i32);
2433 pub const R16G16B16A16_SFLOAT: Self = Self(97i32);
2434 pub const R32_UINT: Self = Self(98i32);
2435 pub const R32_SINT: Self = Self(99i32);
2436 pub const R32_SFLOAT: Self = Self(100i32);
2437 pub const R32G32_UINT: Self = Self(101i32);
2438 pub const R32G32_SINT: Self = Self(102i32);
2439 pub const R32G32_SFLOAT: Self = Self(103i32);
2440 pub const R32G32B32_UINT: Self = Self(104i32);
2441 pub const R32G32B32_SINT: Self = Self(105i32);
2442 pub const R32G32B32_SFLOAT: Self = Self(106i32);
2443 pub const R32G32B32A32_UINT: Self = Self(107i32);
2444 pub const R32G32B32A32_SINT: Self = Self(108i32);
2445 pub const R32G32B32A32_SFLOAT: Self = Self(109i32);
2446 pub const R64_UINT: Self = Self(110i32);
2447 pub const R64_SINT: Self = Self(111i32);
2448 pub const R64_SFLOAT: Self = Self(112i32);
2449 pub const R64G64_UINT: Self = Self(113i32);
2450 pub const R64G64_SINT: Self = Self(114i32);
2451 pub const R64G64_SFLOAT: Self = Self(115i32);
2452 pub const R64G64B64_UINT: Self = Self(116i32);
2453 pub const R64G64B64_SINT: Self = Self(117i32);
2454 pub const R64G64B64_SFLOAT: Self = Self(118i32);
2455 pub const R64G64B64A64_UINT: Self = Self(119i32);
2456 pub const R64G64B64A64_SINT: Self = Self(120i32);
2457 pub const R64G64B64A64_SFLOAT: Self = Self(121i32);
2458 pub const B10G11R11_UFLOAT_PACK32: Self = Self(122i32);
2459 pub const E5B9G9R9_UFLOAT_PACK32: Self = Self(123i32);
2460 pub const D16_UNORM: Self = Self(124i32);
2461 pub const X8_D24_UNORM_PACK32: Self = Self(125i32);
2462 pub const D32_SFLOAT: Self = Self(126i32);
2463 pub const S8_UINT: Self = Self(127i32);
2464 pub const D16_UNORM_S8_UINT: Self = Self(128i32);
2465 pub const D24_UNORM_S8_UINT: Self = Self(129i32);
2466 pub const D32_SFLOAT_S8_UINT: Self = Self(130i32);
2467 pub const BC1_RGB_UNORM_BLOCK: Self = Self(131i32);
2468 pub const BC1_RGB_SRGB_BLOCK: Self = Self(132i32);
2469 pub const BC1_RGBA_UNORM_BLOCK: Self = Self(133i32);
2470 pub const BC1_RGBA_SRGB_BLOCK: Self = Self(134i32);
2471 pub const BC2_UNORM_BLOCK: Self = Self(135i32);
2472 pub const BC2_SRGB_BLOCK: Self = Self(136i32);
2473 pub const BC3_UNORM_BLOCK: Self = Self(137i32);
2474 pub const BC3_SRGB_BLOCK: Self = Self(138i32);
2475 pub const BC4_UNORM_BLOCK: Self = Self(139i32);
2476 pub const BC4_SNORM_BLOCK: Self = Self(140i32);
2477 pub const BC5_UNORM_BLOCK: Self = Self(141i32);
2478 pub const BC5_SNORM_BLOCK: Self = Self(142i32);
2479 pub const BC6H_UFLOAT_BLOCK: Self = Self(143i32);
2480 pub const BC6H_SFLOAT_BLOCK: Self = Self(144i32);
2481 pub const BC7_UNORM_BLOCK: Self = Self(145i32);
2482 pub const BC7_SRGB_BLOCK: Self = Self(146i32);
2483 pub const ETC2_R8G8B8_UNORM_BLOCK: Self = Self(147i32);
2484 pub const ETC2_R8G8B8_SRGB_BLOCK: Self = Self(148i32);
2485 pub const ETC2_R8G8B8A1_UNORM_BLOCK: Self = Self(149i32);
2486 pub const ETC2_R8G8B8A1_SRGB_BLOCK: Self = Self(150i32);
2487 pub const ETC2_R8G8B8A8_UNORM_BLOCK: Self = Self(151i32);
2488 pub const ETC2_R8G8B8A8_SRGB_BLOCK: Self = Self(152i32);
2489 pub const EAC_R11_UNORM_BLOCK: Self = Self(153i32);
2490 pub const EAC_R11_SNORM_BLOCK: Self = Self(154i32);
2491 pub const EAC_R11G11_UNORM_BLOCK: Self = Self(155i32);
2492 pub const EAC_R11G11_SNORM_BLOCK: Self = Self(156i32);
2493 pub const ASTC_4x4_UNORM_BLOCK: Self = Self(157i32);
2494 pub const ASTC_4x4_SRGB_BLOCK: Self = Self(158i32);
2495 pub const ASTC_5x4_UNORM_BLOCK: Self = Self(159i32);
2496 pub const ASTC_5x4_SRGB_BLOCK: Self = Self(160i32);
2497 pub const ASTC_5x5_UNORM_BLOCK: Self = Self(161i32);
2498 pub const ASTC_5x5_SRGB_BLOCK: Self = Self(162i32);
2499 pub const ASTC_6x5_UNORM_BLOCK: Self = Self(163i32);
2500 pub const ASTC_6x5_SRGB_BLOCK: Self = Self(164i32);
2501 pub const ASTC_6x6_UNORM_BLOCK: Self = Self(165i32);
2502 pub const ASTC_6x6_SRGB_BLOCK: Self = Self(166i32);
2503 pub const ASTC_8x5_UNORM_BLOCK: Self = Self(167i32);
2504 pub const ASTC_8x5_SRGB_BLOCK: Self = Self(168i32);
2505 pub const ASTC_8x6_UNORM_BLOCK: Self = Self(169i32);
2506 pub const ASTC_8x6_SRGB_BLOCK: Self = Self(170i32);
2507 pub const ASTC_8x8_UNORM_BLOCK: Self = Self(171i32);
2508 pub const ASTC_8x8_SRGB_BLOCK: Self = Self(172i32);
2509 pub const ASTC_10x5_UNORM_BLOCK: Self = Self(173i32);
2510 pub const ASTC_10x5_SRGB_BLOCK: Self = Self(174i32);
2511 pub const ASTC_10x6_UNORM_BLOCK: Self = Self(175i32);
2512 pub const ASTC_10x6_SRGB_BLOCK: Self = Self(176i32);
2513 pub const ASTC_10x8_UNORM_BLOCK: Self = Self(177i32);
2514 pub const ASTC_10x8_SRGB_BLOCK: Self = Self(178i32);
2515 pub const ASTC_10x10_UNORM_BLOCK: Self = Self(179i32);
2516 pub const ASTC_10x10_SRGB_BLOCK: Self = Self(180i32);
2517 pub const ASTC_12x10_UNORM_BLOCK: Self = Self(181i32);
2518 pub const ASTC_12x10_SRGB_BLOCK: Self = Self(182i32);
2519 pub const ASTC_12x12_UNORM_BLOCK: Self = Self(183i32);
2520 pub const ASTC_12x12_SRGB_BLOCK: Self = Self(184i32);
2521 pub const G8B8G8R8_422_UNORM: Self = Self(1000156000i32);
2522 pub const B8G8R8G8_422_UNORM: Self = Self(1000156001i32);
2523 pub const G8_B8_R8_3PLANE_420_UNORM: Self = Self(1000156002i32);
2524 pub const G8_B8R8_2PLANE_420_UNORM: Self = Self(1000156003i32);
2525 pub const G8_B8_R8_3PLANE_422_UNORM: Self = Self(1000156004i32);
2526 pub const G8_B8R8_2PLANE_422_UNORM: Self = Self(1000156005i32);
2527 pub const G8_B8_R8_3PLANE_444_UNORM: Self = Self(1000156006i32);
2528 pub const R10X6_UNORM_PACK16: Self = Self(1000156007i32);
2529 pub const R10X6G10X6_UNORM_2PACK16: Self = Self(1000156008i32);
2530 pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Self(1000156009i32);
2531 pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Self(1000156010i32);
2532 pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Self(1000156011i32);
2533 pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Self(1000156012i32);
2534 pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Self(1000156013i32);
2535 pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Self(1000156014i32);
2536 pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Self(1000156015i32);
2537 pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Self(1000156016i32);
2538 pub const R12X4_UNORM_PACK16: Self = Self(1000156017i32);
2539 pub const R12X4G12X4_UNORM_2PACK16: Self = Self(1000156018i32);
2540 pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Self(1000156019i32);
2541 pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Self(1000156020i32);
2542 pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Self(1000156021i32);
2543 pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Self(1000156022i32);
2544 pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Self(1000156023i32);
2545 pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Self(1000156024i32);
2546 pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Self(1000156025i32);
2547 pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Self(1000156026i32);
2548 pub const G16B16G16R16_422_UNORM: Self = Self(1000156027i32);
2549 pub const B16G16R16G16_422_UNORM: Self = Self(1000156028i32);
2550 pub const G16_B16_R16_3PLANE_420_UNORM: Self = Self(1000156029i32);
2551 pub const G16_B16R16_2PLANE_420_UNORM: Self = Self(1000156030i32);
2552 pub const G16_B16_R16_3PLANE_422_UNORM: Self = Self(1000156031i32);
2553 pub const G16_B16R16_2PLANE_422_UNORM: Self = Self(1000156032i32);
2554 pub const G16_B16_R16_3PLANE_444_UNORM: Self = Self(1000156033i32);
2555 pub const G8_B8R8_2PLANE_444_UNORM: Self = Self(1000330000i32);
2556 pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: Self = Self(1000330001i32);
2557 pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: Self = Self(1000330002i32);
2558 pub const G16_B16R16_2PLANE_444_UNORM: Self = Self(1000330003i32);
2559 pub const A4R4G4B4_UNORM_PACK16: Self = Self(1000340000i32);
2560 pub const A4B4G4R4_UNORM_PACK16: Self = Self(1000340001i32);
2561 pub const ASTC_4x4_SFLOAT_BLOCK: Self = Self(1000066000i32);
2562 pub const ASTC_5x4_SFLOAT_BLOCK: Self = Self(1000066001i32);
2563 pub const ASTC_5x5_SFLOAT_BLOCK: Self = Self(1000066002i32);
2564 pub const ASTC_6x5_SFLOAT_BLOCK: Self = Self(1000066003i32);
2565 pub const ASTC_6x6_SFLOAT_BLOCK: Self = Self(1000066004i32);
2566 pub const ASTC_8x5_SFLOAT_BLOCK: Self = Self(1000066005i32);
2567 pub const ASTC_8x6_SFLOAT_BLOCK: Self = Self(1000066006i32);
2568 pub const ASTC_8x8_SFLOAT_BLOCK: Self = Self(1000066007i32);
2569 pub const ASTC_10x5_SFLOAT_BLOCK: Self = Self(1000066008i32);
2570 pub const ASTC_10x6_SFLOAT_BLOCK: Self = Self(1000066009i32);
2571 pub const ASTC_10x8_SFLOAT_BLOCK: Self = Self(1000066010i32);
2572 pub const ASTC_10x10_SFLOAT_BLOCK: Self = Self(1000066011i32);
2573 pub const ASTC_12x10_SFLOAT_BLOCK: Self = Self(1000066012i32);
2574 pub const ASTC_12x12_SFLOAT_BLOCK: Self = Self(1000066013i32);
2575 pub const A1B5G5R5_UNORM_PACK16: Self = Self(1000470000i32);
2576 pub const A8_UNORM: Self = Self(1000470001i32);
2577 pub const PVRTC1_2BPP_UNORM_BLOCK: Self = Self(1000054000i32);
2578 pub const PVRTC1_4BPP_UNORM_BLOCK: Self = Self(1000054001i32);
2579 pub const PVRTC2_2BPP_UNORM_BLOCK: Self = Self(1000054002i32);
2580 pub const PVRTC2_4BPP_UNORM_BLOCK: Self = Self(1000054003i32);
2581 pub const PVRTC1_2BPP_SRGB_BLOCK: Self = Self(1000054004i32);
2582 pub const PVRTC1_4BPP_SRGB_BLOCK: Self = Self(1000054005i32);
2583 pub const PVRTC2_2BPP_SRGB_BLOCK: Self = Self(1000054006i32);
2584 pub const PVRTC2_4BPP_SRGB_BLOCK: Self = Self(1000054007i32);
2585 pub const ASTC_3x3x3_UNORM_BLOCK: Self = Self(1000288000i32);
2586 pub const ASTC_3x3x3_SRGB_BLOCK: Self = Self(1000288001i32);
2587 pub const ASTC_3x3x3_SFLOAT_BLOCK: Self = Self(1000288002i32);
2588 pub const ASTC_4x3x3_UNORM_BLOCK: Self = Self(1000288003i32);
2589 pub const ASTC_4x3x3_SRGB_BLOCK: Self = Self(1000288004i32);
2590 pub const ASTC_4x3x3_SFLOAT_BLOCK: Self = Self(1000288005i32);
2591 pub const ASTC_4x4x3_UNORM_BLOCK: Self = Self(1000288006i32);
2592 pub const ASTC_4x4x3_SRGB_BLOCK: Self = Self(1000288007i32);
2593 pub const ASTC_4x4x3_SFLOAT_BLOCK: Self = Self(1000288008i32);
2594 pub const ASTC_4x4x4_UNORM_BLOCK: Self = Self(1000288009i32);
2595 pub const ASTC_4x4x4_SRGB_BLOCK: Self = Self(1000288010i32);
2596 pub const ASTC_4x4x4_SFLOAT_BLOCK: Self = Self(1000288011i32);
2597 pub const ASTC_5x4x4_UNORM_BLOCK: Self = Self(1000288012i32);
2598 pub const ASTC_5x4x4_SRGB_BLOCK: Self = Self(1000288013i32);
2599 pub const ASTC_5x4x4_SFLOAT_BLOCK: Self = Self(1000288014i32);
2600 pub const ASTC_5x5x4_UNORM_BLOCK: Self = Self(1000288015i32);
2601 pub const ASTC_5x5x4_SRGB_BLOCK: Self = Self(1000288016i32);
2602 pub const ASTC_5x5x4_SFLOAT_BLOCK: Self = Self(1000288017i32);
2603 pub const ASTC_5x5x5_UNORM_BLOCK: Self = Self(1000288018i32);
2604 pub const ASTC_5x5x5_SRGB_BLOCK: Self = Self(1000288019i32);
2605 pub const ASTC_5x5x5_SFLOAT_BLOCK: Self = Self(1000288020i32);
2606 pub const ASTC_6x5x5_UNORM_BLOCK: Self = Self(1000288021i32);
2607 pub const ASTC_6x5x5_SRGB_BLOCK: Self = Self(1000288022i32);
2608 pub const ASTC_6x5x5_SFLOAT_BLOCK: Self = Self(1000288023i32);
2609 pub const ASTC_6x6x5_UNORM_BLOCK: Self = Self(1000288024i32);
2610 pub const ASTC_6x6x5_SRGB_BLOCK: Self = Self(1000288025i32);
2611 pub const ASTC_6x6x5_SFLOAT_BLOCK: Self = Self(1000288026i32);
2612 pub const ASTC_6x6x6_UNORM_BLOCK: Self = Self(1000288027i32);
2613 pub const ASTC_6x6x6_SRGB_BLOCK: Self = Self(1000288028i32);
2614 pub const ASTC_6x6x6_SFLOAT_BLOCK: Self = Self(1000288029i32);
2615 pub const R8_BOOL: Self = Self(1000460000i32);
2616 pub const R16_SFLOAT_FPENCODING_BFLOAT16: Self = Self(1000460001i32);
2617 pub const R8_SFLOAT_FPENCODING_FLOAT8E4M3: Self = Self(1000460002i32);
2618 pub const R8_SFLOAT_FPENCODING_FLOAT8E5M2: Self = Self(1000460003i32);
2619 pub const R16G16_SFIXED5: Self = Self(1000464000i32);
2620 pub const R16G16_S10_5: Self = Self::R16G16_SFIXED5;
2621 pub const R10X6_UINT_PACK16: Self = Self(1000609000i32);
2622 pub const R10X6G10X6_UINT_2PACK16: Self = Self(1000609001i32);
2623 pub const R10X6G10X6B10X6A10X6_UINT_4PACK16: Self = Self(1000609002i32);
2624 pub const R12X4_UINT_PACK16: Self = Self(1000609003i32);
2625 pub const R12X4G12X4_UINT_2PACK16: Self = Self(1000609004i32);
2626 pub const R12X4G12X4B12X4A12X4_UINT_4PACK16: Self = Self(1000609005i32);
2627 pub const R14X2_UINT_PACK16: Self = Self(1000609006i32);
2628 pub const R14X2G14X2_UINT_2PACK16: Self = Self(1000609007i32);
2629 pub const R14X2G14X2B14X2A14X2_UINT_4PACK16: Self = Self(1000609008i32);
2630 pub const R14X2_UNORM_PACK16: Self = Self(1000609009i32);
2631 pub const R14X2G14X2_UNORM_2PACK16: Self = Self(1000609010i32);
2632 pub const R14X2G14X2B14X2A14X2_UNORM_4PACK16: Self = Self(1000609011i32);
2633 pub const G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16: Self = Self(1000609012i32);
2634 pub const G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16: Self = Self(1000609013i32);
2635 #[inline]
2636 pub const fn from_raw(value: i32) -> Self {
2637 Self(value)
2638 }
2639 #[inline]
2640 pub const fn as_raw(self) -> i32 {
2641 self.0
2642 }
2643}
2644impl core::fmt::Debug for Format {
2645 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2646 match self.0 {
2647 0i32 => f.write_str("UNDEFINED"),
2648 1i32 => f.write_str("R4G4_UNORM_PACK8"),
2649 2i32 => f.write_str("R4G4B4A4_UNORM_PACK16"),
2650 3i32 => f.write_str("B4G4R4A4_UNORM_PACK16"),
2651 4i32 => f.write_str("R5G6B5_UNORM_PACK16"),
2652 5i32 => f.write_str("B5G6R5_UNORM_PACK16"),
2653 6i32 => f.write_str("R5G5B5A1_UNORM_PACK16"),
2654 7i32 => f.write_str("B5G5R5A1_UNORM_PACK16"),
2655 8i32 => f.write_str("A1R5G5B5_UNORM_PACK16"),
2656 9i32 => f.write_str("R8_UNORM"),
2657 10i32 => f.write_str("R8_SNORM"),
2658 11i32 => f.write_str("R8_USCALED"),
2659 12i32 => f.write_str("R8_SSCALED"),
2660 13i32 => f.write_str("R8_UINT"),
2661 14i32 => f.write_str("R8_SINT"),
2662 15i32 => f.write_str("R8_SRGB"),
2663 16i32 => f.write_str("R8G8_UNORM"),
2664 17i32 => f.write_str("R8G8_SNORM"),
2665 18i32 => f.write_str("R8G8_USCALED"),
2666 19i32 => f.write_str("R8G8_SSCALED"),
2667 20i32 => f.write_str("R8G8_UINT"),
2668 21i32 => f.write_str("R8G8_SINT"),
2669 22i32 => f.write_str("R8G8_SRGB"),
2670 23i32 => f.write_str("R8G8B8_UNORM"),
2671 24i32 => f.write_str("R8G8B8_SNORM"),
2672 25i32 => f.write_str("R8G8B8_USCALED"),
2673 26i32 => f.write_str("R8G8B8_SSCALED"),
2674 27i32 => f.write_str("R8G8B8_UINT"),
2675 28i32 => f.write_str("R8G8B8_SINT"),
2676 29i32 => f.write_str("R8G8B8_SRGB"),
2677 30i32 => f.write_str("B8G8R8_UNORM"),
2678 31i32 => f.write_str("B8G8R8_SNORM"),
2679 32i32 => f.write_str("B8G8R8_USCALED"),
2680 33i32 => f.write_str("B8G8R8_SSCALED"),
2681 34i32 => f.write_str("B8G8R8_UINT"),
2682 35i32 => f.write_str("B8G8R8_SINT"),
2683 36i32 => f.write_str("B8G8R8_SRGB"),
2684 37i32 => f.write_str("R8G8B8A8_UNORM"),
2685 38i32 => f.write_str("R8G8B8A8_SNORM"),
2686 39i32 => f.write_str("R8G8B8A8_USCALED"),
2687 40i32 => f.write_str("R8G8B8A8_SSCALED"),
2688 41i32 => f.write_str("R8G8B8A8_UINT"),
2689 42i32 => f.write_str("R8G8B8A8_SINT"),
2690 43i32 => f.write_str("R8G8B8A8_SRGB"),
2691 44i32 => f.write_str("B8G8R8A8_UNORM"),
2692 45i32 => f.write_str("B8G8R8A8_SNORM"),
2693 46i32 => f.write_str("B8G8R8A8_USCALED"),
2694 47i32 => f.write_str("B8G8R8A8_SSCALED"),
2695 48i32 => f.write_str("B8G8R8A8_UINT"),
2696 49i32 => f.write_str("B8G8R8A8_SINT"),
2697 50i32 => f.write_str("B8G8R8A8_SRGB"),
2698 51i32 => f.write_str("A8B8G8R8_UNORM_PACK32"),
2699 52i32 => f.write_str("A8B8G8R8_SNORM_PACK32"),
2700 53i32 => f.write_str("A8B8G8R8_USCALED_PACK32"),
2701 54i32 => f.write_str("A8B8G8R8_SSCALED_PACK32"),
2702 55i32 => f.write_str("A8B8G8R8_UINT_PACK32"),
2703 56i32 => f.write_str("A8B8G8R8_SINT_PACK32"),
2704 57i32 => f.write_str("A8B8G8R8_SRGB_PACK32"),
2705 58i32 => f.write_str("A2R10G10B10_UNORM_PACK32"),
2706 59i32 => f.write_str("A2R10G10B10_SNORM_PACK32"),
2707 60i32 => f.write_str("A2R10G10B10_USCALED_PACK32"),
2708 61i32 => f.write_str("A2R10G10B10_SSCALED_PACK32"),
2709 62i32 => f.write_str("A2R10G10B10_UINT_PACK32"),
2710 63i32 => f.write_str("A2R10G10B10_SINT_PACK32"),
2711 64i32 => f.write_str("A2B10G10R10_UNORM_PACK32"),
2712 65i32 => f.write_str("A2B10G10R10_SNORM_PACK32"),
2713 66i32 => f.write_str("A2B10G10R10_USCALED_PACK32"),
2714 67i32 => f.write_str("A2B10G10R10_SSCALED_PACK32"),
2715 68i32 => f.write_str("A2B10G10R10_UINT_PACK32"),
2716 69i32 => f.write_str("A2B10G10R10_SINT_PACK32"),
2717 70i32 => f.write_str("R16_UNORM"),
2718 71i32 => f.write_str("R16_SNORM"),
2719 72i32 => f.write_str("R16_USCALED"),
2720 73i32 => f.write_str("R16_SSCALED"),
2721 74i32 => f.write_str("R16_UINT"),
2722 75i32 => f.write_str("R16_SINT"),
2723 76i32 => f.write_str("R16_SFLOAT"),
2724 77i32 => f.write_str("R16G16_UNORM"),
2725 78i32 => f.write_str("R16G16_SNORM"),
2726 79i32 => f.write_str("R16G16_USCALED"),
2727 80i32 => f.write_str("R16G16_SSCALED"),
2728 81i32 => f.write_str("R16G16_UINT"),
2729 82i32 => f.write_str("R16G16_SINT"),
2730 83i32 => f.write_str("R16G16_SFLOAT"),
2731 84i32 => f.write_str("R16G16B16_UNORM"),
2732 85i32 => f.write_str("R16G16B16_SNORM"),
2733 86i32 => f.write_str("R16G16B16_USCALED"),
2734 87i32 => f.write_str("R16G16B16_SSCALED"),
2735 88i32 => f.write_str("R16G16B16_UINT"),
2736 89i32 => f.write_str("R16G16B16_SINT"),
2737 90i32 => f.write_str("R16G16B16_SFLOAT"),
2738 91i32 => f.write_str("R16G16B16A16_UNORM"),
2739 92i32 => f.write_str("R16G16B16A16_SNORM"),
2740 93i32 => f.write_str("R16G16B16A16_USCALED"),
2741 94i32 => f.write_str("R16G16B16A16_SSCALED"),
2742 95i32 => f.write_str("R16G16B16A16_UINT"),
2743 96i32 => f.write_str("R16G16B16A16_SINT"),
2744 97i32 => f.write_str("R16G16B16A16_SFLOAT"),
2745 98i32 => f.write_str("R32_UINT"),
2746 99i32 => f.write_str("R32_SINT"),
2747 100i32 => f.write_str("R32_SFLOAT"),
2748 101i32 => f.write_str("R32G32_UINT"),
2749 102i32 => f.write_str("R32G32_SINT"),
2750 103i32 => f.write_str("R32G32_SFLOAT"),
2751 104i32 => f.write_str("R32G32B32_UINT"),
2752 105i32 => f.write_str("R32G32B32_SINT"),
2753 106i32 => f.write_str("R32G32B32_SFLOAT"),
2754 107i32 => f.write_str("R32G32B32A32_UINT"),
2755 108i32 => f.write_str("R32G32B32A32_SINT"),
2756 109i32 => f.write_str("R32G32B32A32_SFLOAT"),
2757 110i32 => f.write_str("R64_UINT"),
2758 111i32 => f.write_str("R64_SINT"),
2759 112i32 => f.write_str("R64_SFLOAT"),
2760 113i32 => f.write_str("R64G64_UINT"),
2761 114i32 => f.write_str("R64G64_SINT"),
2762 115i32 => f.write_str("R64G64_SFLOAT"),
2763 116i32 => f.write_str("R64G64B64_UINT"),
2764 117i32 => f.write_str("R64G64B64_SINT"),
2765 118i32 => f.write_str("R64G64B64_SFLOAT"),
2766 119i32 => f.write_str("R64G64B64A64_UINT"),
2767 120i32 => f.write_str("R64G64B64A64_SINT"),
2768 121i32 => f.write_str("R64G64B64A64_SFLOAT"),
2769 122i32 => f.write_str("B10G11R11_UFLOAT_PACK32"),
2770 123i32 => f.write_str("E5B9G9R9_UFLOAT_PACK32"),
2771 124i32 => f.write_str("D16_UNORM"),
2772 125i32 => f.write_str("X8_D24_UNORM_PACK32"),
2773 126i32 => f.write_str("D32_SFLOAT"),
2774 127i32 => f.write_str("S8_UINT"),
2775 128i32 => f.write_str("D16_UNORM_S8_UINT"),
2776 129i32 => f.write_str("D24_UNORM_S8_UINT"),
2777 130i32 => f.write_str("D32_SFLOAT_S8_UINT"),
2778 131i32 => f.write_str("BC1_RGB_UNORM_BLOCK"),
2779 132i32 => f.write_str("BC1_RGB_SRGB_BLOCK"),
2780 133i32 => f.write_str("BC1_RGBA_UNORM_BLOCK"),
2781 134i32 => f.write_str("BC1_RGBA_SRGB_BLOCK"),
2782 135i32 => f.write_str("BC2_UNORM_BLOCK"),
2783 136i32 => f.write_str("BC2_SRGB_BLOCK"),
2784 137i32 => f.write_str("BC3_UNORM_BLOCK"),
2785 138i32 => f.write_str("BC3_SRGB_BLOCK"),
2786 139i32 => f.write_str("BC4_UNORM_BLOCK"),
2787 140i32 => f.write_str("BC4_SNORM_BLOCK"),
2788 141i32 => f.write_str("BC5_UNORM_BLOCK"),
2789 142i32 => f.write_str("BC5_SNORM_BLOCK"),
2790 143i32 => f.write_str("BC6H_UFLOAT_BLOCK"),
2791 144i32 => f.write_str("BC6H_SFLOAT_BLOCK"),
2792 145i32 => f.write_str("BC7_UNORM_BLOCK"),
2793 146i32 => f.write_str("BC7_SRGB_BLOCK"),
2794 147i32 => f.write_str("ETC2_R8G8B8_UNORM_BLOCK"),
2795 148i32 => f.write_str("ETC2_R8G8B8_SRGB_BLOCK"),
2796 149i32 => f.write_str("ETC2_R8G8B8A1_UNORM_BLOCK"),
2797 150i32 => f.write_str("ETC2_R8G8B8A1_SRGB_BLOCK"),
2798 151i32 => f.write_str("ETC2_R8G8B8A8_UNORM_BLOCK"),
2799 152i32 => f.write_str("ETC2_R8G8B8A8_SRGB_BLOCK"),
2800 153i32 => f.write_str("EAC_R11_UNORM_BLOCK"),
2801 154i32 => f.write_str("EAC_R11_SNORM_BLOCK"),
2802 155i32 => f.write_str("EAC_R11G11_UNORM_BLOCK"),
2803 156i32 => f.write_str("EAC_R11G11_SNORM_BLOCK"),
2804 157i32 => f.write_str("ASTC_4x4_UNORM_BLOCK"),
2805 158i32 => f.write_str("ASTC_4x4_SRGB_BLOCK"),
2806 159i32 => f.write_str("ASTC_5x4_UNORM_BLOCK"),
2807 160i32 => f.write_str("ASTC_5x4_SRGB_BLOCK"),
2808 161i32 => f.write_str("ASTC_5x5_UNORM_BLOCK"),
2809 162i32 => f.write_str("ASTC_5x5_SRGB_BLOCK"),
2810 163i32 => f.write_str("ASTC_6x5_UNORM_BLOCK"),
2811 164i32 => f.write_str("ASTC_6x5_SRGB_BLOCK"),
2812 165i32 => f.write_str("ASTC_6x6_UNORM_BLOCK"),
2813 166i32 => f.write_str("ASTC_6x6_SRGB_BLOCK"),
2814 167i32 => f.write_str("ASTC_8x5_UNORM_BLOCK"),
2815 168i32 => f.write_str("ASTC_8x5_SRGB_BLOCK"),
2816 169i32 => f.write_str("ASTC_8x6_UNORM_BLOCK"),
2817 170i32 => f.write_str("ASTC_8x6_SRGB_BLOCK"),
2818 171i32 => f.write_str("ASTC_8x8_UNORM_BLOCK"),
2819 172i32 => f.write_str("ASTC_8x8_SRGB_BLOCK"),
2820 173i32 => f.write_str("ASTC_10x5_UNORM_BLOCK"),
2821 174i32 => f.write_str("ASTC_10x5_SRGB_BLOCK"),
2822 175i32 => f.write_str("ASTC_10x6_UNORM_BLOCK"),
2823 176i32 => f.write_str("ASTC_10x6_SRGB_BLOCK"),
2824 177i32 => f.write_str("ASTC_10x8_UNORM_BLOCK"),
2825 178i32 => f.write_str("ASTC_10x8_SRGB_BLOCK"),
2826 179i32 => f.write_str("ASTC_10x10_UNORM_BLOCK"),
2827 180i32 => f.write_str("ASTC_10x10_SRGB_BLOCK"),
2828 181i32 => f.write_str("ASTC_12x10_UNORM_BLOCK"),
2829 182i32 => f.write_str("ASTC_12x10_SRGB_BLOCK"),
2830 183i32 => f.write_str("ASTC_12x12_UNORM_BLOCK"),
2831 184i32 => f.write_str("ASTC_12x12_SRGB_BLOCK"),
2832 1000156000i32 => f.write_str("G8B8G8R8_422_UNORM"),
2833 1000156001i32 => f.write_str("B8G8R8G8_422_UNORM"),
2834 1000156002i32 => f.write_str("G8_B8_R8_3PLANE_420_UNORM"),
2835 1000156003i32 => f.write_str("G8_B8R8_2PLANE_420_UNORM"),
2836 1000156004i32 => f.write_str("G8_B8_R8_3PLANE_422_UNORM"),
2837 1000156005i32 => f.write_str("G8_B8R8_2PLANE_422_UNORM"),
2838 1000156006i32 => f.write_str("G8_B8_R8_3PLANE_444_UNORM"),
2839 1000156007i32 => f.write_str("R10X6_UNORM_PACK16"),
2840 1000156008i32 => f.write_str("R10X6G10X6_UNORM_2PACK16"),
2841 1000156009i32 => f.write_str("R10X6G10X6B10X6A10X6_UNORM_4PACK16"),
2842 1000156010i32 => f.write_str("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"),
2843 1000156011i32 => f.write_str("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"),
2844 1000156012i32 => f.write_str("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"),
2845 1000156013i32 => f.write_str("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"),
2846 1000156014i32 => f.write_str("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"),
2847 1000156015i32 => f.write_str("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"),
2848 1000156016i32 => f.write_str("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"),
2849 1000156017i32 => f.write_str("R12X4_UNORM_PACK16"),
2850 1000156018i32 => f.write_str("R12X4G12X4_UNORM_2PACK16"),
2851 1000156019i32 => f.write_str("R12X4G12X4B12X4A12X4_UNORM_4PACK16"),
2852 1000156020i32 => f.write_str("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"),
2853 1000156021i32 => f.write_str("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"),
2854 1000156022i32 => f.write_str("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"),
2855 1000156023i32 => f.write_str("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"),
2856 1000156024i32 => f.write_str("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"),
2857 1000156025i32 => f.write_str("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"),
2858 1000156026i32 => f.write_str("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"),
2859 1000156027i32 => f.write_str("G16B16G16R16_422_UNORM"),
2860 1000156028i32 => f.write_str("B16G16R16G16_422_UNORM"),
2861 1000156029i32 => f.write_str("G16_B16_R16_3PLANE_420_UNORM"),
2862 1000156030i32 => f.write_str("G16_B16R16_2PLANE_420_UNORM"),
2863 1000156031i32 => f.write_str("G16_B16_R16_3PLANE_422_UNORM"),
2864 1000156032i32 => f.write_str("G16_B16R16_2PLANE_422_UNORM"),
2865 1000156033i32 => f.write_str("G16_B16_R16_3PLANE_444_UNORM"),
2866 1000330000i32 => f.write_str("G8_B8R8_2PLANE_444_UNORM"),
2867 1000330001i32 => f.write_str("G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16"),
2868 1000330002i32 => f.write_str("G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16"),
2869 1000330003i32 => f.write_str("G16_B16R16_2PLANE_444_UNORM"),
2870 1000340000i32 => f.write_str("A4R4G4B4_UNORM_PACK16"),
2871 1000340001i32 => f.write_str("A4B4G4R4_UNORM_PACK16"),
2872 1000066000i32 => f.write_str("ASTC_4x4_SFLOAT_BLOCK"),
2873 1000066001i32 => f.write_str("ASTC_5x4_SFLOAT_BLOCK"),
2874 1000066002i32 => f.write_str("ASTC_5x5_SFLOAT_BLOCK"),
2875 1000066003i32 => f.write_str("ASTC_6x5_SFLOAT_BLOCK"),
2876 1000066004i32 => f.write_str("ASTC_6x6_SFLOAT_BLOCK"),
2877 1000066005i32 => f.write_str("ASTC_8x5_SFLOAT_BLOCK"),
2878 1000066006i32 => f.write_str("ASTC_8x6_SFLOAT_BLOCK"),
2879 1000066007i32 => f.write_str("ASTC_8x8_SFLOAT_BLOCK"),
2880 1000066008i32 => f.write_str("ASTC_10x5_SFLOAT_BLOCK"),
2881 1000066009i32 => f.write_str("ASTC_10x6_SFLOAT_BLOCK"),
2882 1000066010i32 => f.write_str("ASTC_10x8_SFLOAT_BLOCK"),
2883 1000066011i32 => f.write_str("ASTC_10x10_SFLOAT_BLOCK"),
2884 1000066012i32 => f.write_str("ASTC_12x10_SFLOAT_BLOCK"),
2885 1000066013i32 => f.write_str("ASTC_12x12_SFLOAT_BLOCK"),
2886 1000470000i32 => f.write_str("A1B5G5R5_UNORM_PACK16"),
2887 1000470001i32 => f.write_str("A8_UNORM"),
2888 1000054000i32 => f.write_str("PVRTC1_2BPP_UNORM_BLOCK"),
2889 1000054001i32 => f.write_str("PVRTC1_4BPP_UNORM_BLOCK"),
2890 1000054002i32 => f.write_str("PVRTC2_2BPP_UNORM_BLOCK"),
2891 1000054003i32 => f.write_str("PVRTC2_4BPP_UNORM_BLOCK"),
2892 1000054004i32 => f.write_str("PVRTC1_2BPP_SRGB_BLOCK"),
2893 1000054005i32 => f.write_str("PVRTC1_4BPP_SRGB_BLOCK"),
2894 1000054006i32 => f.write_str("PVRTC2_2BPP_SRGB_BLOCK"),
2895 1000054007i32 => f.write_str("PVRTC2_4BPP_SRGB_BLOCK"),
2896 1000288000i32 => f.write_str("ASTC_3x3x3_UNORM_BLOCK"),
2897 1000288001i32 => f.write_str("ASTC_3x3x3_SRGB_BLOCK"),
2898 1000288002i32 => f.write_str("ASTC_3x3x3_SFLOAT_BLOCK"),
2899 1000288003i32 => f.write_str("ASTC_4x3x3_UNORM_BLOCK"),
2900 1000288004i32 => f.write_str("ASTC_4x3x3_SRGB_BLOCK"),
2901 1000288005i32 => f.write_str("ASTC_4x3x3_SFLOAT_BLOCK"),
2902 1000288006i32 => f.write_str("ASTC_4x4x3_UNORM_BLOCK"),
2903 1000288007i32 => f.write_str("ASTC_4x4x3_SRGB_BLOCK"),
2904 1000288008i32 => f.write_str("ASTC_4x4x3_SFLOAT_BLOCK"),
2905 1000288009i32 => f.write_str("ASTC_4x4x4_UNORM_BLOCK"),
2906 1000288010i32 => f.write_str("ASTC_4x4x4_SRGB_BLOCK"),
2907 1000288011i32 => f.write_str("ASTC_4x4x4_SFLOAT_BLOCK"),
2908 1000288012i32 => f.write_str("ASTC_5x4x4_UNORM_BLOCK"),
2909 1000288013i32 => f.write_str("ASTC_5x4x4_SRGB_BLOCK"),
2910 1000288014i32 => f.write_str("ASTC_5x4x4_SFLOAT_BLOCK"),
2911 1000288015i32 => f.write_str("ASTC_5x5x4_UNORM_BLOCK"),
2912 1000288016i32 => f.write_str("ASTC_5x5x4_SRGB_BLOCK"),
2913 1000288017i32 => f.write_str("ASTC_5x5x4_SFLOAT_BLOCK"),
2914 1000288018i32 => f.write_str("ASTC_5x5x5_UNORM_BLOCK"),
2915 1000288019i32 => f.write_str("ASTC_5x5x5_SRGB_BLOCK"),
2916 1000288020i32 => f.write_str("ASTC_5x5x5_SFLOAT_BLOCK"),
2917 1000288021i32 => f.write_str("ASTC_6x5x5_UNORM_BLOCK"),
2918 1000288022i32 => f.write_str("ASTC_6x5x5_SRGB_BLOCK"),
2919 1000288023i32 => f.write_str("ASTC_6x5x5_SFLOAT_BLOCK"),
2920 1000288024i32 => f.write_str("ASTC_6x6x5_UNORM_BLOCK"),
2921 1000288025i32 => f.write_str("ASTC_6x6x5_SRGB_BLOCK"),
2922 1000288026i32 => f.write_str("ASTC_6x6x5_SFLOAT_BLOCK"),
2923 1000288027i32 => f.write_str("ASTC_6x6x6_UNORM_BLOCK"),
2924 1000288028i32 => f.write_str("ASTC_6x6x6_SRGB_BLOCK"),
2925 1000288029i32 => f.write_str("ASTC_6x6x6_SFLOAT_BLOCK"),
2926 1000460000i32 => f.write_str("R8_BOOL"),
2927 1000460001i32 => f.write_str("R16_SFLOAT_FPENCODING_BFLOAT16"),
2928 1000460002i32 => f.write_str("R8_SFLOAT_FPENCODING_FLOAT8E4M3"),
2929 1000460003i32 => f.write_str("R8_SFLOAT_FPENCODING_FLOAT8E5M2"),
2930 1000464000i32 => f.write_str("R16G16_SFIXED5"),
2931 1000609000i32 => f.write_str("R10X6_UINT_PACK16"),
2932 1000609001i32 => f.write_str("R10X6G10X6_UINT_2PACK16"),
2933 1000609002i32 => f.write_str("R10X6G10X6B10X6A10X6_UINT_4PACK16"),
2934 1000609003i32 => f.write_str("R12X4_UINT_PACK16"),
2935 1000609004i32 => f.write_str("R12X4G12X4_UINT_2PACK16"),
2936 1000609005i32 => f.write_str("R12X4G12X4B12X4A12X4_UINT_4PACK16"),
2937 1000609006i32 => f.write_str("R14X2_UINT_PACK16"),
2938 1000609007i32 => f.write_str("R14X2G14X2_UINT_2PACK16"),
2939 1000609008i32 => f.write_str("R14X2G14X2B14X2A14X2_UINT_4PACK16"),
2940 1000609009i32 => f.write_str("R14X2_UNORM_PACK16"),
2941 1000609010i32 => f.write_str("R14X2G14X2_UNORM_2PACK16"),
2942 1000609011i32 => f.write_str("R14X2G14X2B14X2A14X2_UNORM_4PACK16"),
2943 1000609012i32 => f.write_str("G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16"),
2944 1000609013i32 => f.write_str("G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16"),
2945 other => write!(f, "{}({})", stringify!(Format), other),
2946 }
2947 }
2948}
2949#[repr(transparent)]
2951#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2952#[doc(alias = "VkFragmentShadingRateCombinerOpKHR")]
2953pub struct FragmentShadingRateCombinerOpKHR(i32);
2954impl FragmentShadingRateCombinerOpKHR {
2955 pub const KEEP: Self = Self(0i32);
2956 pub const REPLACE: Self = Self(1i32);
2957 pub const MIN: Self = Self(2i32);
2958 pub const MAX: Self = Self(3i32);
2959 pub const MUL: Self = Self(4i32);
2960 #[inline]
2961 pub const fn from_raw(value: i32) -> Self {
2962 Self(value)
2963 }
2964 #[inline]
2965 pub const fn as_raw(self) -> i32 {
2966 self.0
2967 }
2968}
2969impl core::fmt::Debug for FragmentShadingRateCombinerOpKHR {
2970 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2971 match self.0 {
2972 0i32 => f.write_str("KEEP"),
2973 1i32 => f.write_str("REPLACE"),
2974 2i32 => f.write_str("MIN"),
2975 3i32 => f.write_str("MAX"),
2976 4i32 => f.write_str("MUL"),
2977 other => {
2978 write!(f, "{}({})", stringify!(FragmentShadingRateCombinerOpKHR), other)
2979 }
2980 }
2981 }
2982}
2983#[repr(transparent)]
2985#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2986#[doc(alias = "VkFragmentShadingRateNV")]
2987pub struct FragmentShadingRateNV(i32);
2988impl FragmentShadingRateNV {
2989 pub const _1_INVOCATION_PER_PIXEL: Self = Self(0i32);
2990 pub const _1_INVOCATION_PER_1X2_PIXELS: Self = Self(1i32);
2991 pub const _1_INVOCATION_PER_2X1_PIXELS: Self = Self(4i32);
2992 pub const _1_INVOCATION_PER_2X2_PIXELS: Self = Self(5i32);
2993 pub const _1_INVOCATION_PER_2X4_PIXELS: Self = Self(6i32);
2994 pub const _1_INVOCATION_PER_4X2_PIXELS: Self = Self(9i32);
2995 pub const _1_INVOCATION_PER_4X4_PIXELS: Self = Self(10i32);
2996 pub const _2_INVOCATIONS_PER_PIXEL: Self = Self(11i32);
2997 pub const _4_INVOCATIONS_PER_PIXEL: Self = Self(12i32);
2998 pub const _8_INVOCATIONS_PER_PIXEL: Self = Self(13i32);
2999 pub const _16_INVOCATIONS_PER_PIXEL: Self = Self(14i32);
3000 pub const NO_INVOCATIONS: Self = Self(15i32);
3001 #[inline]
3002 pub const fn from_raw(value: i32) -> Self {
3003 Self(value)
3004 }
3005 #[inline]
3006 pub const fn as_raw(self) -> i32 {
3007 self.0
3008 }
3009}
3010impl core::fmt::Debug for FragmentShadingRateNV {
3011 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3012 match self.0 {
3013 0i32 => f.write_str("_1_INVOCATION_PER_PIXEL"),
3014 1i32 => f.write_str("_1_INVOCATION_PER_1X2_PIXELS"),
3015 4i32 => f.write_str("_1_INVOCATION_PER_2X1_PIXELS"),
3016 5i32 => f.write_str("_1_INVOCATION_PER_2X2_PIXELS"),
3017 6i32 => f.write_str("_1_INVOCATION_PER_2X4_PIXELS"),
3018 9i32 => f.write_str("_1_INVOCATION_PER_4X2_PIXELS"),
3019 10i32 => f.write_str("_1_INVOCATION_PER_4X4_PIXELS"),
3020 11i32 => f.write_str("_2_INVOCATIONS_PER_PIXEL"),
3021 12i32 => f.write_str("_4_INVOCATIONS_PER_PIXEL"),
3022 13i32 => f.write_str("_8_INVOCATIONS_PER_PIXEL"),
3023 14i32 => f.write_str("_16_INVOCATIONS_PER_PIXEL"),
3024 15i32 => f.write_str("NO_INVOCATIONS"),
3025 other => write!(f, "{}({})", stringify!(FragmentShadingRateNV), other),
3026 }
3027 }
3028}
3029#[repr(transparent)]
3031#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3032#[doc(alias = "VkFragmentShadingRateTypeNV")]
3033pub struct FragmentShadingRateTypeNV(i32);
3034impl FragmentShadingRateTypeNV {
3035 pub const FRAGMENT_SIZE: Self = Self(0i32);
3036 pub const ENUMS: Self = Self(1i32);
3037 #[inline]
3038 pub const fn from_raw(value: i32) -> Self {
3039 Self(value)
3040 }
3041 #[inline]
3042 pub const fn as_raw(self) -> i32 {
3043 self.0
3044 }
3045}
3046impl core::fmt::Debug for FragmentShadingRateTypeNV {
3047 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3048 match self.0 {
3049 0i32 => f.write_str("FRAGMENT_SIZE"),
3050 1i32 => f.write_str("ENUMS"),
3051 other => write!(f, "{}({})", stringify!(FragmentShadingRateTypeNV), other),
3052 }
3053 }
3054}
3055#[repr(transparent)]
3057#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3058#[doc(alias = "VkFrontFace")]
3059pub struct FrontFace(i32);
3060impl FrontFace {
3061 pub const COUNTER_CLOCKWISE: Self = Self(0i32);
3062 pub const CLOCKWISE: Self = Self(1i32);
3063 #[inline]
3064 pub const fn from_raw(value: i32) -> Self {
3065 Self(value)
3066 }
3067 #[inline]
3068 pub const fn as_raw(self) -> i32 {
3069 self.0
3070 }
3071}
3072impl core::fmt::Debug for FrontFace {
3073 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3074 match self.0 {
3075 0i32 => f.write_str("COUNTER_CLOCKWISE"),
3076 1i32 => f.write_str("CLOCKWISE"),
3077 other => write!(f, "{}({})", stringify!(FrontFace), other),
3078 }
3079 }
3080}
3081#[repr(transparent)]
3083#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3084#[doc(alias = "VkFullScreenExclusiveEXT")]
3085pub struct FullScreenExclusiveEXT(i32);
3086impl FullScreenExclusiveEXT {
3087 pub const DEFAULT: Self = Self(0i32);
3088 pub const ALLOWED: Self = Self(1i32);
3089 pub const DISALLOWED: Self = Self(2i32);
3090 pub const APPLICATION_CONTROLLED: Self = Self(3i32);
3091 #[inline]
3092 pub const fn from_raw(value: i32) -> Self {
3093 Self(value)
3094 }
3095 #[inline]
3096 pub const fn as_raw(self) -> i32 {
3097 self.0
3098 }
3099}
3100impl core::fmt::Debug for FullScreenExclusiveEXT {
3101 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3102 match self.0 {
3103 0i32 => f.write_str("DEFAULT"),
3104 1i32 => f.write_str("ALLOWED"),
3105 2i32 => f.write_str("DISALLOWED"),
3106 3i32 => f.write_str("APPLICATION_CONTROLLED"),
3107 other => write!(f, "{}({})", stringify!(FullScreenExclusiveEXT), other),
3108 }
3109 }
3110}
3111#[repr(transparent)]
3113#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3114#[doc(alias = "VkGeometryTypeKHR")]
3115pub struct GeometryTypeKHR(i32);
3116impl GeometryTypeKHR {
3117 pub const TRIANGLES: Self = Self(0i32);
3118 pub const AABBS: Self = Self(1i32);
3119 pub const INSTANCES: Self = Self(2i32);
3120 pub const SPHERES: Self = Self(1000429004i32);
3121 pub const LINEAR_SWEPT_SPHERES: Self = Self(1000429005i32);
3122 pub const DENSE_GEOMETRY_FORMAT_TRIANGLES: Self = Self(1000478000i32);
3123 #[inline]
3124 pub const fn from_raw(value: i32) -> Self {
3125 Self(value)
3126 }
3127 #[inline]
3128 pub const fn as_raw(self) -> i32 {
3129 self.0
3130 }
3131}
3132impl core::fmt::Debug for GeometryTypeKHR {
3133 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3134 match self.0 {
3135 0i32 => f.write_str("TRIANGLES"),
3136 1i32 => f.write_str("AABBS"),
3137 2i32 => f.write_str("INSTANCES"),
3138 1000429004i32 => f.write_str("SPHERES"),
3139 1000429005i32 => f.write_str("LINEAR_SWEPT_SPHERES"),
3140 1000478000i32 => f.write_str("DENSE_GEOMETRY_FORMAT_TRIANGLES"),
3141 other => write!(f, "{}({})", stringify!(GeometryTypeKHR), other),
3142 }
3143 }
3144}
3145#[repr(transparent)]
3147#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3148#[doc(alias = "VkImageLayout")]
3149pub struct ImageLayout(i32);
3150impl ImageLayout {
3151 pub const UNDEFINED: Self = Self(0i32);
3153 pub const GENERAL: Self = Self(1i32);
3155 pub const COLOR_ATTACHMENT_OPTIMAL: Self = Self(2i32);
3157 pub const DEPTH_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(3i32);
3159 pub const DEPTH_STENCIL_READ_ONLY_OPTIMAL: Self = Self(4i32);
3161 pub const SHADER_READ_ONLY_OPTIMAL: Self = Self(5i32);
3163 pub const TRANSFER_SRC_OPTIMAL: Self = Self(6i32);
3165 pub const TRANSFER_DST_OPTIMAL: Self = Self(7i32);
3167 pub const PREINITIALIZED: Self = Self(8i32);
3169 pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1000117000i32);
3170 pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = Self(1000117001i32);
3171 pub const DEPTH_ATTACHMENT_OPTIMAL: Self = Self(1000241000i32);
3172 pub const DEPTH_READ_ONLY_OPTIMAL: Self = Self(1000241001i32);
3173 pub const STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1000241002i32);
3174 pub const STENCIL_READ_ONLY_OPTIMAL: Self = Self(1000241003i32);
3175 pub const READ_ONLY_OPTIMAL: Self = Self(1000314000i32);
3176 pub const ATTACHMENT_OPTIMAL: Self = Self(1000314001i32);
3177 pub const RENDERING_LOCAL_READ: Self = Self(1000232000i32);
3178 pub const PRESENT_SRC: Self = Self(1000001002i32);
3179 pub const VIDEO_DECODE_DST: Self = Self(1000024000i32);
3180 pub const VIDEO_DECODE_SRC: Self = Self(1000024001i32);
3181 pub const VIDEO_DECODE_DPB: Self = Self(1000024002i32);
3182 pub const SHARED_PRESENT: Self = Self(1000111000i32);
3183 pub const SHADING_RATE_OPTIMAL: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL;
3184 pub const FRAGMENT_DENSITY_MAP_OPTIMAL: Self = Self(1000218000i32);
3185 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL: Self = Self(1000164003i32);
3186 pub const VIDEO_ENCODE_DST: Self = Self(1000299000i32);
3187 pub const VIDEO_ENCODE_SRC: Self = Self(1000299001i32);
3188 pub const VIDEO_ENCODE_DPB: Self = Self(1000299002i32);
3189 pub const ATTACHMENT_FEEDBACK_LOOP_OPTIMAL: Self = Self(1000339000i32);
3190 pub const TENSOR_ALIASING: Self = Self(1000460000i32);
3191 pub const VIDEO_ENCODE_QUANTIZATION_MAP: Self = Self(1000553000i32);
3192 pub const ZERO_INITIALIZED: Self = Self(1000620000i32);
3193 #[inline]
3194 pub const fn from_raw(value: i32) -> Self {
3195 Self(value)
3196 }
3197 #[inline]
3198 pub const fn as_raw(self) -> i32 {
3199 self.0
3200 }
3201}
3202impl core::fmt::Debug for ImageLayout {
3203 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3204 match self.0 {
3205 0i32 => f.write_str("UNDEFINED"),
3206 1i32 => f.write_str("GENERAL"),
3207 2i32 => f.write_str("COLOR_ATTACHMENT_OPTIMAL"),
3208 3i32 => f.write_str("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"),
3209 4i32 => f.write_str("DEPTH_STENCIL_READ_ONLY_OPTIMAL"),
3210 5i32 => f.write_str("SHADER_READ_ONLY_OPTIMAL"),
3211 6i32 => f.write_str("TRANSFER_SRC_OPTIMAL"),
3212 7i32 => f.write_str("TRANSFER_DST_OPTIMAL"),
3213 8i32 => f.write_str("PREINITIALIZED"),
3214 1000117000i32 => f.write_str("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"),
3215 1000117001i32 => f.write_str("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"),
3216 1000241000i32 => f.write_str("DEPTH_ATTACHMENT_OPTIMAL"),
3217 1000241001i32 => f.write_str("DEPTH_READ_ONLY_OPTIMAL"),
3218 1000241002i32 => f.write_str("STENCIL_ATTACHMENT_OPTIMAL"),
3219 1000241003i32 => f.write_str("STENCIL_READ_ONLY_OPTIMAL"),
3220 1000314000i32 => f.write_str("READ_ONLY_OPTIMAL"),
3221 1000314001i32 => f.write_str("ATTACHMENT_OPTIMAL"),
3222 1000232000i32 => f.write_str("RENDERING_LOCAL_READ"),
3223 1000001002i32 => f.write_str("PRESENT_SRC"),
3224 1000024000i32 => f.write_str("VIDEO_DECODE_DST"),
3225 1000024001i32 => f.write_str("VIDEO_DECODE_SRC"),
3226 1000024002i32 => f.write_str("VIDEO_DECODE_DPB"),
3227 1000111000i32 => f.write_str("SHARED_PRESENT"),
3228 1000218000i32 => f.write_str("FRAGMENT_DENSITY_MAP_OPTIMAL"),
3229 1000164003i32 => f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL"),
3230 1000299000i32 => f.write_str("VIDEO_ENCODE_DST"),
3231 1000299001i32 => f.write_str("VIDEO_ENCODE_SRC"),
3232 1000299002i32 => f.write_str("VIDEO_ENCODE_DPB"),
3233 1000339000i32 => f.write_str("ATTACHMENT_FEEDBACK_LOOP_OPTIMAL"),
3234 1000460000i32 => f.write_str("TENSOR_ALIASING"),
3235 1000553000i32 => f.write_str("VIDEO_ENCODE_QUANTIZATION_MAP"),
3236 1000620000i32 => f.write_str("ZERO_INITIALIZED"),
3237 other => write!(f, "{}({})", stringify!(ImageLayout), other),
3238 }
3239 }
3240}
3241#[repr(transparent)]
3243#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3244#[doc(alias = "VkImageTiling")]
3245pub struct ImageTiling(i32);
3246impl ImageTiling {
3247 pub const OPTIMAL: Self = Self(0i32);
3248 pub const LINEAR: Self = Self(1i32);
3249 pub const DRM_FORMAT_MODIFIER: Self = Self(1000158000i32);
3250 #[inline]
3251 pub const fn from_raw(value: i32) -> Self {
3252 Self(value)
3253 }
3254 #[inline]
3255 pub const fn as_raw(self) -> i32 {
3256 self.0
3257 }
3258}
3259impl core::fmt::Debug for ImageTiling {
3260 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3261 match self.0 {
3262 0i32 => f.write_str("OPTIMAL"),
3263 1i32 => f.write_str("LINEAR"),
3264 1000158000i32 => f.write_str("DRM_FORMAT_MODIFIER"),
3265 other => write!(f, "{}({})", stringify!(ImageTiling), other),
3266 }
3267 }
3268}
3269#[repr(transparent)]
3271#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3272#[doc(alias = "VkImageType")]
3273pub struct ImageType(i32);
3274impl ImageType {
3275 pub const _1D: Self = Self(0i32);
3276 pub const _2D: Self = Self(1i32);
3277 pub const _3D: Self = Self(2i32);
3278 #[inline]
3279 pub const fn from_raw(value: i32) -> Self {
3280 Self(value)
3281 }
3282 #[inline]
3283 pub const fn as_raw(self) -> i32 {
3284 self.0
3285 }
3286}
3287impl core::fmt::Debug for ImageType {
3288 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3289 match self.0 {
3290 0i32 => f.write_str("_1D"),
3291 1i32 => f.write_str("_2D"),
3292 2i32 => f.write_str("_3D"),
3293 other => write!(f, "{}({})", stringify!(ImageType), other),
3294 }
3295 }
3296}
3297#[repr(transparent)]
3299#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3300#[doc(alias = "VkImageViewType")]
3301pub struct ImageViewType(i32);
3302impl ImageViewType {
3303 pub const _1D: Self = Self(0i32);
3304 pub const _2D: Self = Self(1i32);
3305 pub const _3D: Self = Self(2i32);
3306 pub const CUBE: Self = Self(3i32);
3307 pub const _1D_ARRAY: Self = Self(4i32);
3308 pub const _2D_ARRAY: Self = Self(5i32);
3309 pub const CUBE_ARRAY: Self = Self(6i32);
3310 #[inline]
3311 pub const fn from_raw(value: i32) -> Self {
3312 Self(value)
3313 }
3314 #[inline]
3315 pub const fn as_raw(self) -> i32 {
3316 self.0
3317 }
3318}
3319impl core::fmt::Debug for ImageViewType {
3320 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3321 match self.0 {
3322 0i32 => f.write_str("_1D"),
3323 1i32 => f.write_str("_2D"),
3324 2i32 => f.write_str("_3D"),
3325 3i32 => f.write_str("CUBE"),
3326 4i32 => f.write_str("_1D_ARRAY"),
3327 5i32 => f.write_str("_2D_ARRAY"),
3328 6i32 => f.write_str("CUBE_ARRAY"),
3329 other => write!(f, "{}({})", stringify!(ImageViewType), other),
3330 }
3331 }
3332}
3333#[repr(transparent)]
3335#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3336#[doc(alias = "VkIndexType")]
3337pub struct IndexType(i32);
3338impl IndexType {
3339 pub const UINT16: Self = Self(0i32);
3340 pub const UINT32: Self = Self(1i32);
3341 pub const UINT8: Self = Self(1000265000i32);
3342 pub const NONE: Self = Self(1000165000i32);
3343 #[inline]
3344 pub const fn from_raw(value: i32) -> Self {
3345 Self(value)
3346 }
3347 #[inline]
3348 pub const fn as_raw(self) -> i32 {
3349 self.0
3350 }
3351}
3352impl core::fmt::Debug for IndexType {
3353 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3354 match self.0 {
3355 0i32 => f.write_str("UINT16"),
3356 1i32 => f.write_str("UINT32"),
3357 1000265000i32 => f.write_str("UINT8"),
3358 1000165000i32 => f.write_str("NONE"),
3359 other => write!(f, "{}({})", stringify!(IndexType), other),
3360 }
3361 }
3362}
3363#[repr(transparent)]
3365#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3366#[doc(alias = "VkIndirectCommandsTokenTypeEXT")]
3367pub struct IndirectCommandsTokenTypeEXT(i32);
3368impl IndirectCommandsTokenTypeEXT {
3369 pub const EXECUTION_SET: Self = Self(0i32);
3370 pub const PUSH_CONSTANT: Self = Self(1i32);
3371 pub const SEQUENCE_INDEX: Self = Self(2i32);
3372 pub const INDEX_BUFFER: Self = Self(3i32);
3373 pub const VERTEX_BUFFER: Self = Self(4i32);
3374 pub const DRAW_INDEXED: Self = Self(5i32);
3375 pub const DRAW: Self = Self(6i32);
3376 pub const DRAW_INDEXED_COUNT: Self = Self(7i32);
3377 pub const DRAW_COUNT: Self = Self(8i32);
3378 pub const DISPATCH: Self = Self(9i32);
3379 pub const PUSH_DATA: Self = Self(1000135000i32);
3380 pub const PUSH_DATA_SEQUENCE_INDEX: Self = Self(1000135001i32);
3381 pub const DRAW_MESH_TASKS_: Self = Self(1000202002i32);
3382 pub const DRAW_MESH_TASKS_COUNT_: Self = Self(1000202003i32);
3383 pub const DRAW_MESH_TASKS: Self = Self(1000328000i32);
3384 pub const DRAW_MESH_TASKS_COUNT: Self = Self(1000328001i32);
3385 pub const TRACE_RAYS2: Self = Self(1000386004i32);
3386 #[inline]
3387 pub const fn from_raw(value: i32) -> Self {
3388 Self(value)
3389 }
3390 #[inline]
3391 pub const fn as_raw(self) -> i32 {
3392 self.0
3393 }
3394}
3395impl core::fmt::Debug for IndirectCommandsTokenTypeEXT {
3396 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3397 match self.0 {
3398 0i32 => f.write_str("EXECUTION_SET"),
3399 1i32 => f.write_str("PUSH_CONSTANT"),
3400 2i32 => f.write_str("SEQUENCE_INDEX"),
3401 3i32 => f.write_str("INDEX_BUFFER"),
3402 4i32 => f.write_str("VERTEX_BUFFER"),
3403 5i32 => f.write_str("DRAW_INDEXED"),
3404 6i32 => f.write_str("DRAW"),
3405 7i32 => f.write_str("DRAW_INDEXED_COUNT"),
3406 8i32 => f.write_str("DRAW_COUNT"),
3407 9i32 => f.write_str("DISPATCH"),
3408 1000135000i32 => f.write_str("PUSH_DATA"),
3409 1000135001i32 => f.write_str("PUSH_DATA_SEQUENCE_INDEX"),
3410 1000202002i32 => f.write_str("DRAW_MESH_TASKS_"),
3411 1000202003i32 => f.write_str("DRAW_MESH_TASKS_COUNT_"),
3412 1000328000i32 => f.write_str("DRAW_MESH_TASKS"),
3413 1000328001i32 => f.write_str("DRAW_MESH_TASKS_COUNT"),
3414 1000386004i32 => f.write_str("TRACE_RAYS2"),
3415 other => write!(f, "{}({})", stringify!(IndirectCommandsTokenTypeEXT), other),
3416 }
3417 }
3418}
3419#[repr(transparent)]
3421#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3422#[doc(alias = "VkIndirectCommandsTokenTypeNV")]
3423pub struct IndirectCommandsTokenTypeNV(i32);
3424impl IndirectCommandsTokenTypeNV {
3425 pub const SHADER_GROUP: Self = Self(0i32);
3426 pub const STATE_FLAGS: Self = Self(1i32);
3427 pub const INDEX_BUFFER: Self = Self(2i32);
3428 pub const VERTEX_BUFFER: Self = Self(3i32);
3429 pub const PUSH_CONSTANT: Self = Self(4i32);
3430 pub const DRAW_INDEXED: Self = Self(5i32);
3431 pub const DRAW: Self = Self(6i32);
3432 pub const DRAW_TASKS: Self = Self(7i32);
3433 pub const PUSH_DATA: Self = Self(1000135000i32);
3434 pub const DRAW_MESH_TASKS: Self = Self(1000328000i32);
3435 pub const PIPELINE: Self = Self(1000428003i32);
3436 pub const DISPATCH: Self = Self(1000428004i32);
3437 #[inline]
3438 pub const fn from_raw(value: i32) -> Self {
3439 Self(value)
3440 }
3441 #[inline]
3442 pub const fn as_raw(self) -> i32 {
3443 self.0
3444 }
3445}
3446impl core::fmt::Debug for IndirectCommandsTokenTypeNV {
3447 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3448 match self.0 {
3449 0i32 => f.write_str("SHADER_GROUP"),
3450 1i32 => f.write_str("STATE_FLAGS"),
3451 2i32 => f.write_str("INDEX_BUFFER"),
3452 3i32 => f.write_str("VERTEX_BUFFER"),
3453 4i32 => f.write_str("PUSH_CONSTANT"),
3454 5i32 => f.write_str("DRAW_INDEXED"),
3455 6i32 => f.write_str("DRAW"),
3456 7i32 => f.write_str("DRAW_TASKS"),
3457 1000135000i32 => f.write_str("PUSH_DATA"),
3458 1000328000i32 => f.write_str("DRAW_MESH_TASKS"),
3459 1000428003i32 => f.write_str("PIPELINE"),
3460 1000428004i32 => f.write_str("DISPATCH"),
3461 other => write!(f, "{}({})", stringify!(IndirectCommandsTokenTypeNV), other),
3462 }
3463 }
3464}
3465#[repr(transparent)]
3467#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3468#[doc(alias = "VkIndirectExecutionSetInfoTypeEXT")]
3469pub struct IndirectExecutionSetInfoTypeEXT(i32);
3470impl IndirectExecutionSetInfoTypeEXT {
3471 pub const PIPELINES: Self = Self(0i32);
3472 pub const SHADER_OBJECTS: Self = Self(1i32);
3473 #[inline]
3474 pub const fn from_raw(value: i32) -> Self {
3475 Self(value)
3476 }
3477 #[inline]
3478 pub const fn as_raw(self) -> i32 {
3479 self.0
3480 }
3481}
3482impl core::fmt::Debug for IndirectExecutionSetInfoTypeEXT {
3483 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3484 match self.0 {
3485 0i32 => f.write_str("PIPELINES"),
3486 1i32 => f.write_str("SHADER_OBJECTS"),
3487 other => {
3488 write!(f, "{}({})", stringify!(IndirectExecutionSetInfoTypeEXT), other)
3489 }
3490 }
3491 }
3492}
3493#[repr(transparent)]
3495#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3496#[doc(alias = "VkInternalAllocationType")]
3497pub struct InternalAllocationType(i32);
3498impl InternalAllocationType {
3499 pub const EXECUTABLE: Self = Self(0i32);
3500 #[inline]
3501 pub const fn from_raw(value: i32) -> Self {
3502 Self(value)
3503 }
3504 #[inline]
3505 pub const fn as_raw(self) -> i32 {
3506 self.0
3507 }
3508}
3509impl core::fmt::Debug for InternalAllocationType {
3510 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3511 match self.0 {
3512 0i32 => f.write_str("EXECUTABLE"),
3513 other => write!(f, "{}({})", stringify!(InternalAllocationType), other),
3514 }
3515 }
3516}
3517#[repr(transparent)]
3519#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3520#[doc(alias = "VkLatencyMarkerNV")]
3521pub struct LatencyMarkerNV(i32);
3522impl LatencyMarkerNV {
3523 pub const SIMULATION_START: Self = Self(0i32);
3524 pub const SIMULATION_END: Self = Self(1i32);
3525 pub const RENDERSUBMIT_START: Self = Self(2i32);
3526 pub const RENDERSUBMIT_END: Self = Self(3i32);
3527 pub const PRESENT_START: Self = Self(4i32);
3528 pub const PRESENT_END: Self = Self(5i32);
3529 pub const INPUT_SAMPLE: Self = Self(6i32);
3530 pub const TRIGGER_FLASH: Self = Self(7i32);
3531 pub const OUT_OF_BAND_RENDERSUBMIT_START: Self = Self(8i32);
3532 pub const OUT_OF_BAND_RENDERSUBMIT_END: Self = Self(9i32);
3533 pub const OUT_OF_BAND_PRESENT_START: Self = Self(10i32);
3534 pub const OUT_OF_BAND_PRESENT_END: Self = Self(11i32);
3535 #[inline]
3536 pub const fn from_raw(value: i32) -> Self {
3537 Self(value)
3538 }
3539 #[inline]
3540 pub const fn as_raw(self) -> i32 {
3541 self.0
3542 }
3543}
3544impl core::fmt::Debug for LatencyMarkerNV {
3545 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3546 match self.0 {
3547 0i32 => f.write_str("SIMULATION_START"),
3548 1i32 => f.write_str("SIMULATION_END"),
3549 2i32 => f.write_str("RENDERSUBMIT_START"),
3550 3i32 => f.write_str("RENDERSUBMIT_END"),
3551 4i32 => f.write_str("PRESENT_START"),
3552 5i32 => f.write_str("PRESENT_END"),
3553 6i32 => f.write_str("INPUT_SAMPLE"),
3554 7i32 => f.write_str("TRIGGER_FLASH"),
3555 8i32 => f.write_str("OUT_OF_BAND_RENDERSUBMIT_START"),
3556 9i32 => f.write_str("OUT_OF_BAND_RENDERSUBMIT_END"),
3557 10i32 => f.write_str("OUT_OF_BAND_PRESENT_START"),
3558 11i32 => f.write_str("OUT_OF_BAND_PRESENT_END"),
3559 other => write!(f, "{}({})", stringify!(LatencyMarkerNV), other),
3560 }
3561 }
3562}
3563#[repr(transparent)]
3565#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3566#[doc(alias = "VkLayerSettingTypeEXT")]
3567pub struct LayerSettingTypeEXT(i32);
3568impl LayerSettingTypeEXT {
3569 pub const BOOL32: Self = Self(0i32);
3570 pub const INT32: Self = Self(1i32);
3571 pub const INT64: Self = Self(2i32);
3572 pub const UINT32: Self = Self(3i32);
3573 pub const UINT64: Self = Self(4i32);
3574 pub const FLOAT32: Self = Self(5i32);
3575 pub const FLOAT64: Self = Self(6i32);
3576 pub const STRING: Self = Self(7i32);
3577 #[inline]
3578 pub const fn from_raw(value: i32) -> Self {
3579 Self(value)
3580 }
3581 #[inline]
3582 pub const fn as_raw(self) -> i32 {
3583 self.0
3584 }
3585}
3586impl core::fmt::Debug for LayerSettingTypeEXT {
3587 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3588 match self.0 {
3589 0i32 => f.write_str("BOOL32"),
3590 1i32 => f.write_str("INT32"),
3591 2i32 => f.write_str("INT64"),
3592 3i32 => f.write_str("UINT32"),
3593 4i32 => f.write_str("UINT64"),
3594 5i32 => f.write_str("FLOAT32"),
3595 6i32 => f.write_str("FLOAT64"),
3596 7i32 => f.write_str("STRING"),
3597 other => write!(f, "{}({})", stringify!(LayerSettingTypeEXT), other),
3598 }
3599 }
3600}
3601#[repr(transparent)]
3603#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3604#[doc(alias = "VkLayeredDriverUnderlyingApiMSFT")]
3605pub struct LayeredDriverUnderlyingApiMSFT(i32);
3606impl LayeredDriverUnderlyingApiMSFT {
3607 pub const NONE: Self = Self(0i32);
3608 pub const D3D12: Self = Self(1i32);
3609 #[inline]
3610 pub const fn from_raw(value: i32) -> Self {
3611 Self(value)
3612 }
3613 #[inline]
3614 pub const fn as_raw(self) -> i32 {
3615 self.0
3616 }
3617}
3618impl core::fmt::Debug for LayeredDriverUnderlyingApiMSFT {
3619 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3620 match self.0 {
3621 0i32 => f.write_str("NONE"),
3622 1i32 => f.write_str("D3D12"),
3623 other => {
3624 write!(f, "{}({})", stringify!(LayeredDriverUnderlyingApiMSFT), other)
3625 }
3626 }
3627 }
3628}
3629#[repr(transparent)]
3631#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3632#[doc(alias = "VkLineRasterizationMode")]
3633pub struct LineRasterizationMode(i32);
3634impl LineRasterizationMode {
3635 pub const DEFAULT: Self = Self(0i32);
3636 pub const RECTANGULAR: Self = Self(1i32);
3637 pub const BRESENHAM: Self = Self(2i32);
3638 pub const RECTANGULAR_SMOOTH: Self = Self(3i32);
3639 #[inline]
3640 pub const fn from_raw(value: i32) -> Self {
3641 Self(value)
3642 }
3643 #[inline]
3644 pub const fn as_raw(self) -> i32 {
3645 self.0
3646 }
3647}
3648impl core::fmt::Debug for LineRasterizationMode {
3649 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3650 match self.0 {
3651 0i32 => f.write_str("DEFAULT"),
3652 1i32 => f.write_str("RECTANGULAR"),
3653 2i32 => f.write_str("BRESENHAM"),
3654 3i32 => f.write_str("RECTANGULAR_SMOOTH"),
3655 other => write!(f, "{}({})", stringify!(LineRasterizationMode), other),
3656 }
3657 }
3658}
3659#[repr(transparent)]
3661#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3662#[doc(alias = "VkLogicOp")]
3663pub struct LogicOp(i32);
3664impl LogicOp {
3665 pub const CLEAR: Self = Self(0i32);
3666 pub const AND: Self = Self(1i32);
3667 pub const AND_REVERSE: Self = Self(2i32);
3668 pub const COPY: Self = Self(3i32);
3669 pub const AND_INVERTED: Self = Self(4i32);
3670 pub const NO_OP: Self = Self(5i32);
3671 pub const XOR: Self = Self(6i32);
3672 pub const OR: Self = Self(7i32);
3673 pub const NOR: Self = Self(8i32);
3674 pub const EQUIVALENT: Self = Self(9i32);
3675 pub const INVERT: Self = Self(10i32);
3676 pub const OR_REVERSE: Self = Self(11i32);
3677 pub const COPY_INVERTED: Self = Self(12i32);
3678 pub const OR_INVERTED: Self = Self(13i32);
3679 pub const NAND: Self = Self(14i32);
3680 pub const SET: Self = Self(15i32);
3681 #[inline]
3682 pub const fn from_raw(value: i32) -> Self {
3683 Self(value)
3684 }
3685 #[inline]
3686 pub const fn as_raw(self) -> i32 {
3687 self.0
3688 }
3689}
3690impl core::fmt::Debug for LogicOp {
3691 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3692 match self.0 {
3693 0i32 => f.write_str("CLEAR"),
3694 1i32 => f.write_str("AND"),
3695 2i32 => f.write_str("AND_REVERSE"),
3696 3i32 => f.write_str("COPY"),
3697 4i32 => f.write_str("AND_INVERTED"),
3698 5i32 => f.write_str("NO_OP"),
3699 6i32 => f.write_str("XOR"),
3700 7i32 => f.write_str("OR"),
3701 8i32 => f.write_str("NOR"),
3702 9i32 => f.write_str("EQUIVALENT"),
3703 10i32 => f.write_str("INVERT"),
3704 11i32 => f.write_str("OR_REVERSE"),
3705 12i32 => f.write_str("COPY_INVERTED"),
3706 13i32 => f.write_str("OR_INVERTED"),
3707 14i32 => f.write_str("NAND"),
3708 15i32 => f.write_str("SET"),
3709 other => write!(f, "{}({})", stringify!(LogicOp), other),
3710 }
3711 }
3712}
3713#[repr(transparent)]
3715#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3716#[doc(alias = "VkMemoryOverallocationBehaviorAMD")]
3717pub struct MemoryOverallocationBehaviorAMD(i32);
3718impl MemoryOverallocationBehaviorAMD {
3719 pub const DEFAULT: Self = Self(0i32);
3720 pub const ALLOWED: Self = Self(1i32);
3721 pub const DISALLOWED: Self = Self(2i32);
3722 #[inline]
3723 pub const fn from_raw(value: i32) -> Self {
3724 Self(value)
3725 }
3726 #[inline]
3727 pub const fn as_raw(self) -> i32 {
3728 self.0
3729 }
3730}
3731impl core::fmt::Debug for MemoryOverallocationBehaviorAMD {
3732 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3733 match self.0 {
3734 0i32 => f.write_str("DEFAULT"),
3735 1i32 => f.write_str("ALLOWED"),
3736 2i32 => f.write_str("DISALLOWED"),
3737 other => {
3738 write!(f, "{}({})", stringify!(MemoryOverallocationBehaviorAMD), other)
3739 }
3740 }
3741 }
3742}
3743#[repr(transparent)]
3745#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3746#[doc(alias = "VkMicromapTypeEXT")]
3747pub struct MicromapTypeEXT(i32);
3748impl MicromapTypeEXT {
3749 pub const OPACITY_MICROMAP: Self = Self(0i32);
3750 pub const DISPLACEMENT_MICROMAP: Self = Self(1000397000i32);
3751 #[inline]
3752 pub const fn from_raw(value: i32) -> Self {
3753 Self(value)
3754 }
3755 #[inline]
3756 pub const fn as_raw(self) -> i32 {
3757 self.0
3758 }
3759}
3760impl core::fmt::Debug for MicromapTypeEXT {
3761 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3762 match self.0 {
3763 0i32 => f.write_str("OPACITY_MICROMAP"),
3764 1000397000i32 => f.write_str("DISPLACEMENT_MICROMAP"),
3765 other => write!(f, "{}({})", stringify!(MicromapTypeEXT), other),
3766 }
3767 }
3768}
3769#[repr(transparent)]
3771#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3772#[doc(alias = "VkObjectType")]
3773pub struct ObjectType(i32);
3774impl ObjectType {
3775 pub const UNKNOWN: Self = Self(0i32);
3776 pub const INSTANCE: Self = Self(1i32);
3777 pub const PHYSICAL_DEVICE: Self = Self(2i32);
3778 pub const DEVICE: Self = Self(3i32);
3779 pub const QUEUE: Self = Self(4i32);
3780 pub const SEMAPHORE: Self = Self(5i32);
3781 pub const COMMAND_BUFFER: Self = Self(6i32);
3782 pub const FENCE: Self = Self(7i32);
3783 pub const DEVICE_MEMORY: Self = Self(8i32);
3784 pub const BUFFER: Self = Self(9i32);
3785 pub const IMAGE: Self = Self(10i32);
3786 pub const EVENT: Self = Self(11i32);
3787 pub const QUERY_POOL: Self = Self(12i32);
3788 pub const BUFFER_VIEW: Self = Self(13i32);
3789 pub const IMAGE_VIEW: Self = Self(14i32);
3790 pub const SHADER_MODULE: Self = Self(15i32);
3791 pub const PIPELINE_CACHE: Self = Self(16i32);
3792 pub const PIPELINE_LAYOUT: Self = Self(17i32);
3793 pub const RENDER_PASS: Self = Self(18i32);
3794 pub const PIPELINE: Self = Self(19i32);
3795 pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20i32);
3796 pub const SAMPLER: Self = Self(21i32);
3797 pub const DESCRIPTOR_POOL: Self = Self(22i32);
3798 pub const DESCRIPTOR_SET: Self = Self(23i32);
3799 pub const FRAMEBUFFER: Self = Self(24i32);
3800 pub const COMMAND_POOL: Self = Self(25i32);
3801 pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1000085000i32);
3802 pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1000156000i32);
3803 pub const PRIVATE_DATA_SLOT: Self = Self(1000295000i32);
3804 pub const SURFACE: Self = Self(1000000000i32);
3805 pub const SWAPCHAIN: Self = Self(1000001000i32);
3806 pub const DISPLAY: Self = Self(1000002000i32);
3807 pub const DISPLAY_MODE: Self = Self(1000002001i32);
3808 pub const DEBUG_REPORT_CALLBACK: Self = Self(1000011000i32);
3809 pub const VIDEO_SESSION: Self = Self(1000023000i32);
3811 pub const VIDEO_SESSION_PARAMETERS: Self = Self(1000023001i32);
3813 pub const CU_MODULE: Self = Self(1000029000i32);
3814 pub const CU_FUNCTION: Self = Self(1000029001i32);
3815 pub const DEBUG_UTILS_MESSENGER: Self = Self(1000128000i32);
3816 pub const ACCELERATION_STRUCTURE: Self = Self(1000150000i32);
3817 pub const VALIDATION_CACHE: Self = Self(1000160000i32);
3818 pub const PERFORMANCE_CONFIGURATION: Self = Self(1000210000i32);
3819 pub const DEFERRED_OPERATION: Self = Self(1000268000i32);
3820 pub const INDIRECT_COMMANDS_LAYOUT: Self = Self(1000277000i32);
3821 pub const CUDA_MODULE: Self = Self(1000307000i32);
3822 pub const CUDA_FUNCTION: Self = Self(1000307001i32);
3823 pub const BUFFER_COLLECTION: Self = Self(1000366000i32);
3825 pub const MICROMAP: Self = Self(1000396000i32);
3826 pub const TENSOR: Self = Self(1000460000i32);
3827 pub const TENSOR_VIEW: Self = Self(1000460001i32);
3828 pub const OPTICAL_FLOW_SESSION: Self = Self(1000464000i32);
3829 pub const SHADER: Self = Self(1000482000i32);
3830 pub const PIPELINE_BINARY: Self = Self(1000483000i32);
3831 pub const DATA_GRAPH_PIPELINE_SESSION: Self = Self(1000507000i32);
3832 pub const EXTERNAL_COMPUTE_QUEUE: Self = Self(1000556000i32);
3833 pub const INDIRECT_EXECUTION_SET: Self = Self(1000572001i32);
3834 pub const SHADER_INSTRUMENTATION: Self = Self(1000607000i32);
3835 #[inline]
3836 pub const fn from_raw(value: i32) -> Self {
3837 Self(value)
3838 }
3839 #[inline]
3840 pub const fn as_raw(self) -> i32 {
3841 self.0
3842 }
3843}
3844impl core::fmt::Debug for ObjectType {
3845 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3846 match self.0 {
3847 0i32 => f.write_str("UNKNOWN"),
3848 1i32 => f.write_str("INSTANCE"),
3849 2i32 => f.write_str("PHYSICAL_DEVICE"),
3850 3i32 => f.write_str("DEVICE"),
3851 4i32 => f.write_str("QUEUE"),
3852 5i32 => f.write_str("SEMAPHORE"),
3853 6i32 => f.write_str("COMMAND_BUFFER"),
3854 7i32 => f.write_str("FENCE"),
3855 8i32 => f.write_str("DEVICE_MEMORY"),
3856 9i32 => f.write_str("BUFFER"),
3857 10i32 => f.write_str("IMAGE"),
3858 11i32 => f.write_str("EVENT"),
3859 12i32 => f.write_str("QUERY_POOL"),
3860 13i32 => f.write_str("BUFFER_VIEW"),
3861 14i32 => f.write_str("IMAGE_VIEW"),
3862 15i32 => f.write_str("SHADER_MODULE"),
3863 16i32 => f.write_str("PIPELINE_CACHE"),
3864 17i32 => f.write_str("PIPELINE_LAYOUT"),
3865 18i32 => f.write_str("RENDER_PASS"),
3866 19i32 => f.write_str("PIPELINE"),
3867 20i32 => f.write_str("DESCRIPTOR_SET_LAYOUT"),
3868 21i32 => f.write_str("SAMPLER"),
3869 22i32 => f.write_str("DESCRIPTOR_POOL"),
3870 23i32 => f.write_str("DESCRIPTOR_SET"),
3871 24i32 => f.write_str("FRAMEBUFFER"),
3872 25i32 => f.write_str("COMMAND_POOL"),
3873 1000085000i32 => f.write_str("DESCRIPTOR_UPDATE_TEMPLATE"),
3874 1000156000i32 => f.write_str("SAMPLER_YCBCR_CONVERSION"),
3875 1000295000i32 => f.write_str("PRIVATE_DATA_SLOT"),
3876 1000000000i32 => f.write_str("SURFACE"),
3877 1000001000i32 => f.write_str("SWAPCHAIN"),
3878 1000002000i32 => f.write_str("DISPLAY"),
3879 1000002001i32 => f.write_str("DISPLAY_MODE"),
3880 1000011000i32 => f.write_str("DEBUG_REPORT_CALLBACK"),
3881 1000023000i32 => f.write_str("VIDEO_SESSION"),
3882 1000023001i32 => f.write_str("VIDEO_SESSION_PARAMETERS"),
3883 1000029000i32 => f.write_str("CU_MODULE"),
3884 1000029001i32 => f.write_str("CU_FUNCTION"),
3885 1000128000i32 => f.write_str("DEBUG_UTILS_MESSENGER"),
3886 1000150000i32 => f.write_str("ACCELERATION_STRUCTURE"),
3887 1000160000i32 => f.write_str("VALIDATION_CACHE"),
3888 1000210000i32 => f.write_str("PERFORMANCE_CONFIGURATION"),
3889 1000268000i32 => f.write_str("DEFERRED_OPERATION"),
3890 1000277000i32 => f.write_str("INDIRECT_COMMANDS_LAYOUT"),
3891 1000307000i32 => f.write_str("CUDA_MODULE"),
3892 1000307001i32 => f.write_str("CUDA_FUNCTION"),
3893 1000366000i32 => f.write_str("BUFFER_COLLECTION"),
3894 1000396000i32 => f.write_str("MICROMAP"),
3895 1000460000i32 => f.write_str("TENSOR"),
3896 1000460001i32 => f.write_str("TENSOR_VIEW"),
3897 1000464000i32 => f.write_str("OPTICAL_FLOW_SESSION"),
3898 1000482000i32 => f.write_str("SHADER"),
3899 1000483000i32 => f.write_str("PIPELINE_BINARY"),
3900 1000507000i32 => f.write_str("DATA_GRAPH_PIPELINE_SESSION"),
3901 1000556000i32 => f.write_str("EXTERNAL_COMPUTE_QUEUE"),
3902 1000572001i32 => f.write_str("INDIRECT_EXECUTION_SET"),
3903 1000607000i32 => f.write_str("SHADER_INSTRUMENTATION"),
3904 other => write!(f, "{}({})", stringify!(ObjectType), other),
3905 }
3906 }
3907}
3908#[repr(transparent)]
3910#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3911#[doc(alias = "VkOpacityMicromapFormatEXT")]
3912pub struct OpacityMicromapFormatEXT(i32);
3913impl OpacityMicromapFormatEXT {
3914 pub const _2_STATE: Self = Self(1i32);
3915 pub const _4_STATE: Self = Self(2i32);
3916 #[inline]
3917 pub const fn from_raw(value: i32) -> Self {
3918 Self(value)
3919 }
3920 #[inline]
3921 pub const fn as_raw(self) -> i32 {
3922 self.0
3923 }
3924}
3925impl core::fmt::Debug for OpacityMicromapFormatEXT {
3926 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3927 match self.0 {
3928 1i32 => f.write_str("_2_STATE"),
3929 2i32 => f.write_str("_4_STATE"),
3930 other => write!(f, "{}({})", stringify!(OpacityMicromapFormatEXT), other),
3931 }
3932 }
3933}
3934#[repr(transparent)]
3936#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3937#[doc(alias = "VkOpacityMicromapSpecialIndexEXT")]
3938pub struct OpacityMicromapSpecialIndexEXT(i32);
3939impl OpacityMicromapSpecialIndexEXT {
3940 pub const FULLY_TRANSPARENT: Self = Self(-1i32);
3941 pub const FULLY_OPAQUE: Self = Self(-2i32);
3942 pub const FULLY_UNKNOWN_TRANSPARENT: Self = Self(-3i32);
3943 pub const FULLY_UNKNOWN_OPAQUE: Self = Self(-4i32);
3944 pub const CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP: Self = Self(-5i32);
3945 #[inline]
3946 pub const fn from_raw(value: i32) -> Self {
3947 Self(value)
3948 }
3949 #[inline]
3950 pub const fn as_raw(self) -> i32 {
3951 self.0
3952 }
3953}
3954impl core::fmt::Debug for OpacityMicromapSpecialIndexEXT {
3955 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3956 match self.0 {
3957 -1i32 => f.write_str("FULLY_TRANSPARENT"),
3958 -2i32 => f.write_str("FULLY_OPAQUE"),
3959 -3i32 => f.write_str("FULLY_UNKNOWN_TRANSPARENT"),
3960 -4i32 => f.write_str("FULLY_UNKNOWN_OPAQUE"),
3961 -5i32 => f.write_str("CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP"),
3962 other => {
3963 write!(f, "{}({})", stringify!(OpacityMicromapSpecialIndexEXT), other)
3964 }
3965 }
3966 }
3967}
3968#[repr(transparent)]
3970#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3971#[doc(alias = "VkOpticalFlowPerformanceLevelNV")]
3972pub struct OpticalFlowPerformanceLevelNV(i32);
3973impl OpticalFlowPerformanceLevelNV {
3974 pub const UNKNOWN: Self = Self(0i32);
3975 pub const SLOW: Self = Self(1i32);
3976 pub const MEDIUM: Self = Self(2i32);
3977 pub const FAST: Self = Self(3i32);
3978 #[inline]
3979 pub const fn from_raw(value: i32) -> Self {
3980 Self(value)
3981 }
3982 #[inline]
3983 pub const fn as_raw(self) -> i32 {
3984 self.0
3985 }
3986}
3987impl core::fmt::Debug for OpticalFlowPerformanceLevelNV {
3988 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3989 match self.0 {
3990 0i32 => f.write_str("UNKNOWN"),
3991 1i32 => f.write_str("SLOW"),
3992 2i32 => f.write_str("MEDIUM"),
3993 3i32 => f.write_str("FAST"),
3994 other => {
3995 write!(f, "{}({})", stringify!(OpticalFlowPerformanceLevelNV), other)
3996 }
3997 }
3998 }
3999}
4000#[repr(transparent)]
4002#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4003#[doc(alias = "VkOpticalFlowSessionBindingPointNV")]
4004pub struct OpticalFlowSessionBindingPointNV(i32);
4005impl OpticalFlowSessionBindingPointNV {
4006 pub const UNKNOWN: Self = Self(0i32);
4007 pub const INPUT: Self = Self(1i32);
4008 pub const REFERENCE: Self = Self(2i32);
4009 pub const HINT: Self = Self(3i32);
4010 pub const FLOW_VECTOR: Self = Self(4i32);
4011 pub const BACKWARD_FLOW_VECTOR: Self = Self(5i32);
4012 pub const COST: Self = Self(6i32);
4013 pub const BACKWARD_COST: Self = Self(7i32);
4014 pub const GLOBAL_FLOW: Self = Self(8i32);
4015 #[inline]
4016 pub const fn from_raw(value: i32) -> Self {
4017 Self(value)
4018 }
4019 #[inline]
4020 pub const fn as_raw(self) -> i32 {
4021 self.0
4022 }
4023}
4024impl core::fmt::Debug for OpticalFlowSessionBindingPointNV {
4025 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4026 match self.0 {
4027 0i32 => f.write_str("UNKNOWN"),
4028 1i32 => f.write_str("INPUT"),
4029 2i32 => f.write_str("REFERENCE"),
4030 3i32 => f.write_str("HINT"),
4031 4i32 => f.write_str("FLOW_VECTOR"),
4032 5i32 => f.write_str("BACKWARD_FLOW_VECTOR"),
4033 6i32 => f.write_str("COST"),
4034 7i32 => f.write_str("BACKWARD_COST"),
4035 8i32 => f.write_str("GLOBAL_FLOW"),
4036 other => {
4037 write!(f, "{}({})", stringify!(OpticalFlowSessionBindingPointNV), other)
4038 }
4039 }
4040 }
4041}
4042#[repr(transparent)]
4044#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4045#[doc(alias = "VkOutOfBandQueueTypeNV")]
4046pub struct OutOfBandQueueTypeNV(i32);
4047impl OutOfBandQueueTypeNV {
4048 pub const RENDER: Self = Self(0i32);
4049 pub const PRESENT: Self = Self(1i32);
4050 #[inline]
4051 pub const fn from_raw(value: i32) -> Self {
4052 Self(value)
4053 }
4054 #[inline]
4055 pub const fn as_raw(self) -> i32 {
4056 self.0
4057 }
4058}
4059impl core::fmt::Debug for OutOfBandQueueTypeNV {
4060 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4061 match self.0 {
4062 0i32 => f.write_str("RENDER"),
4063 1i32 => f.write_str("PRESENT"),
4064 other => write!(f, "{}({})", stringify!(OutOfBandQueueTypeNV), other),
4065 }
4066 }
4067}
4068#[repr(transparent)]
4070#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4071#[doc(alias = "VkPartitionedAccelerationStructureOpTypeNV")]
4072pub struct PartitionedAccelerationStructureOpTypeNV(i32);
4073impl PartitionedAccelerationStructureOpTypeNV {
4074 pub const WRITE_INSTANCE: Self = Self(0i32);
4075 pub const UPDATE_INSTANCE: Self = Self(1i32);
4076 pub const WRITE_PARTITION_TRANSLATION: Self = Self(2i32);
4077 #[inline]
4078 pub const fn from_raw(value: i32) -> Self {
4079 Self(value)
4080 }
4081 #[inline]
4082 pub const fn as_raw(self) -> i32 {
4083 self.0
4084 }
4085}
4086impl core::fmt::Debug for PartitionedAccelerationStructureOpTypeNV {
4087 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4088 match self.0 {
4089 0i32 => f.write_str("WRITE_INSTANCE"),
4090 1i32 => f.write_str("UPDATE_INSTANCE"),
4091 2i32 => f.write_str("WRITE_PARTITION_TRANSLATION"),
4092 other => {
4093 write!(
4094 f, "{}({})", stringify!(PartitionedAccelerationStructureOpTypeNV),
4095 other
4096 )
4097 }
4098 }
4099 }
4100}
4101#[repr(transparent)]
4103#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4104#[doc(alias = "VkPerformanceConfigurationTypeINTEL")]
4105pub struct PerformanceConfigurationTypeINTEL(i32);
4106impl PerformanceConfigurationTypeINTEL {
4107 pub const COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED: Self = Self(0i32);
4108 #[inline]
4109 pub const fn from_raw(value: i32) -> Self {
4110 Self(value)
4111 }
4112 #[inline]
4113 pub const fn as_raw(self) -> i32 {
4114 self.0
4115 }
4116}
4117impl core::fmt::Debug for PerformanceConfigurationTypeINTEL {
4118 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4119 match self.0 {
4120 0i32 => f.write_str("COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED"),
4121 other => {
4122 write!(f, "{}({})", stringify!(PerformanceConfigurationTypeINTEL), other)
4123 }
4124 }
4125 }
4126}
4127#[repr(transparent)]
4129#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4130#[doc(alias = "VkPerformanceCounterScopeKHR")]
4131pub struct PerformanceCounterScopeKHR(i32);
4132impl PerformanceCounterScopeKHR {
4133 pub const COMMAND_BUFFER: Self = Self(0i32);
4134 pub const RENDER_PASS: Self = Self(1i32);
4135 pub const COMMAND: Self = Self(2i32);
4136 pub const QUERY_SCOPE_COMMAND_BUFFER: Self = Self::COMMAND_BUFFER;
4137 pub const QUERY_SCOPE_RENDER_PASS: Self = Self::RENDER_PASS;
4138 pub const QUERY_SCOPE_COMMAND: Self = Self::COMMAND;
4139 #[inline]
4140 pub const fn from_raw(value: i32) -> Self {
4141 Self(value)
4142 }
4143 #[inline]
4144 pub const fn as_raw(self) -> i32 {
4145 self.0
4146 }
4147}
4148impl core::fmt::Debug for PerformanceCounterScopeKHR {
4149 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4150 match self.0 {
4151 0i32 => f.write_str("COMMAND_BUFFER"),
4152 1i32 => f.write_str("RENDER_PASS"),
4153 2i32 => f.write_str("COMMAND"),
4154 other => write!(f, "{}({})", stringify!(PerformanceCounterScopeKHR), other),
4155 }
4156 }
4157}
4158#[repr(transparent)]
4160#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4161#[doc(alias = "VkPerformanceCounterStorageKHR")]
4162pub struct PerformanceCounterStorageKHR(i32);
4163impl PerformanceCounterStorageKHR {
4164 pub const INT32: Self = Self(0i32);
4165 pub const INT64: Self = Self(1i32);
4166 pub const UINT32: Self = Self(2i32);
4167 pub const UINT64: Self = Self(3i32);
4168 pub const FLOAT32: Self = Self(4i32);
4169 pub const FLOAT64: Self = Self(5i32);
4170 #[inline]
4171 pub const fn from_raw(value: i32) -> Self {
4172 Self(value)
4173 }
4174 #[inline]
4175 pub const fn as_raw(self) -> i32 {
4176 self.0
4177 }
4178}
4179impl core::fmt::Debug for PerformanceCounterStorageKHR {
4180 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4181 match self.0 {
4182 0i32 => f.write_str("INT32"),
4183 1i32 => f.write_str("INT64"),
4184 2i32 => f.write_str("UINT32"),
4185 3i32 => f.write_str("UINT64"),
4186 4i32 => f.write_str("FLOAT32"),
4187 5i32 => f.write_str("FLOAT64"),
4188 other => write!(f, "{}({})", stringify!(PerformanceCounterStorageKHR), other),
4189 }
4190 }
4191}
4192#[repr(transparent)]
4194#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4195#[doc(alias = "VkPerformanceCounterUnitKHR")]
4196pub struct PerformanceCounterUnitKHR(i32);
4197impl PerformanceCounterUnitKHR {
4198 pub const GENERIC: Self = Self(0i32);
4199 pub const PERCENTAGE: Self = Self(1i32);
4200 pub const NANOSECONDS: Self = Self(2i32);
4201 pub const BYTES: Self = Self(3i32);
4202 pub const BYTES_PER_SECOND: Self = Self(4i32);
4203 pub const KELVIN: Self = Self(5i32);
4204 pub const WATTS: Self = Self(6i32);
4205 pub const VOLTS: Self = Self(7i32);
4206 pub const AMPS: Self = Self(8i32);
4207 pub const HERTZ: Self = Self(9i32);
4208 pub const CYCLES: Self = Self(10i32);
4209 #[inline]
4210 pub const fn from_raw(value: i32) -> Self {
4211 Self(value)
4212 }
4213 #[inline]
4214 pub const fn as_raw(self) -> i32 {
4215 self.0
4216 }
4217}
4218impl core::fmt::Debug for PerformanceCounterUnitKHR {
4219 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4220 match self.0 {
4221 0i32 => f.write_str("GENERIC"),
4222 1i32 => f.write_str("PERCENTAGE"),
4223 2i32 => f.write_str("NANOSECONDS"),
4224 3i32 => f.write_str("BYTES"),
4225 4i32 => f.write_str("BYTES_PER_SECOND"),
4226 5i32 => f.write_str("KELVIN"),
4227 6i32 => f.write_str("WATTS"),
4228 7i32 => f.write_str("VOLTS"),
4229 8i32 => f.write_str("AMPS"),
4230 9i32 => f.write_str("HERTZ"),
4231 10i32 => f.write_str("CYCLES"),
4232 other => write!(f, "{}({})", stringify!(PerformanceCounterUnitKHR), other),
4233 }
4234 }
4235}
4236#[repr(transparent)]
4238#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4239#[doc(alias = "VkPerformanceOverrideTypeINTEL")]
4240pub struct PerformanceOverrideTypeINTEL(i32);
4241impl PerformanceOverrideTypeINTEL {
4242 pub const NULL_HARDWARE: Self = Self(0i32);
4243 pub const FLUSH_GPU_CACHES: Self = Self(1i32);
4244 #[inline]
4245 pub const fn from_raw(value: i32) -> Self {
4246 Self(value)
4247 }
4248 #[inline]
4249 pub const fn as_raw(self) -> i32 {
4250 self.0
4251 }
4252}
4253impl core::fmt::Debug for PerformanceOverrideTypeINTEL {
4254 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4255 match self.0 {
4256 0i32 => f.write_str("NULL_HARDWARE"),
4257 1i32 => f.write_str("FLUSH_GPU_CACHES"),
4258 other => write!(f, "{}({})", stringify!(PerformanceOverrideTypeINTEL), other),
4259 }
4260 }
4261}
4262#[repr(transparent)]
4264#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4265#[doc(alias = "VkPerformanceParameterTypeINTEL")]
4266pub struct PerformanceParameterTypeINTEL(i32);
4267impl PerformanceParameterTypeINTEL {
4268 pub const HW_COUNTERS_SUPPORTED: Self = Self(0i32);
4269 pub const STREAM_MARKER_VALID_BITS: Self = Self(1i32);
4270 #[inline]
4271 pub const fn from_raw(value: i32) -> Self {
4272 Self(value)
4273 }
4274 #[inline]
4275 pub const fn as_raw(self) -> i32 {
4276 self.0
4277 }
4278}
4279impl core::fmt::Debug for PerformanceParameterTypeINTEL {
4280 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4281 match self.0 {
4282 0i32 => f.write_str("HW_COUNTERS_SUPPORTED"),
4283 1i32 => f.write_str("STREAM_MARKER_VALID_BITS"),
4284 other => {
4285 write!(f, "{}({})", stringify!(PerformanceParameterTypeINTEL), other)
4286 }
4287 }
4288 }
4289}
4290#[repr(transparent)]
4292#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4293#[doc(alias = "VkPerformanceValueTypeINTEL")]
4294pub struct PerformanceValueTypeINTEL(i32);
4295impl PerformanceValueTypeINTEL {
4296 pub const UINT32: Self = Self(0i32);
4297 pub const UINT64: Self = Self(1i32);
4298 pub const FLOAT: Self = Self(2i32);
4299 pub const BOOL: Self = Self(3i32);
4300 pub const STRING: Self = Self(4i32);
4301 #[inline]
4302 pub const fn from_raw(value: i32) -> Self {
4303 Self(value)
4304 }
4305 #[inline]
4306 pub const fn as_raw(self) -> i32 {
4307 self.0
4308 }
4309}
4310impl core::fmt::Debug for PerformanceValueTypeINTEL {
4311 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4312 match self.0 {
4313 0i32 => f.write_str("UINT32"),
4314 1i32 => f.write_str("UINT64"),
4315 2i32 => f.write_str("FLOAT"),
4316 3i32 => f.write_str("BOOL"),
4317 4i32 => f.write_str("STRING"),
4318 other => write!(f, "{}({})", stringify!(PerformanceValueTypeINTEL), other),
4319 }
4320 }
4321}
4322#[repr(transparent)]
4324#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4325#[doc(alias = "VkPhysicalDeviceDataGraphOperationTypeARM")]
4326pub struct PhysicalDeviceDataGraphOperationTypeARM(i32);
4327impl PhysicalDeviceDataGraphOperationTypeARM {
4328 pub const SPIRV_EXTENDED_INSTRUCTION_SET: Self = Self(0i32);
4329 pub const NEURAL_MODEL: Self = Self(1000629000i32);
4330 pub const BUILTIN_MODEL: Self = Self(1000629001i32);
4331 #[inline]
4332 pub const fn from_raw(value: i32) -> Self {
4333 Self(value)
4334 }
4335 #[inline]
4336 pub const fn as_raw(self) -> i32 {
4337 self.0
4338 }
4339}
4340impl core::fmt::Debug for PhysicalDeviceDataGraphOperationTypeARM {
4341 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4342 match self.0 {
4343 0i32 => f.write_str("SPIRV_EXTENDED_INSTRUCTION_SET"),
4344 1000629000i32 => f.write_str("NEURAL_MODEL"),
4345 1000629001i32 => f.write_str("BUILTIN_MODEL"),
4346 other => {
4347 write!(
4348 f, "{}({})", stringify!(PhysicalDeviceDataGraphOperationTypeARM),
4349 other
4350 )
4351 }
4352 }
4353 }
4354}
4355#[repr(transparent)]
4357#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4358#[doc(alias = "VkPhysicalDeviceDataGraphProcessingEngineTypeARM")]
4359pub struct PhysicalDeviceDataGraphProcessingEngineTypeARM(i32);
4360impl PhysicalDeviceDataGraphProcessingEngineTypeARM {
4361 pub const DEFAULT: Self = Self(0i32);
4362 pub const NEURAL: Self = Self(1000629000i32);
4363 pub const COMPUTE: Self = Self(1000629001i32);
4364 #[inline]
4365 pub const fn from_raw(value: i32) -> Self {
4366 Self(value)
4367 }
4368 #[inline]
4369 pub const fn as_raw(self) -> i32 {
4370 self.0
4371 }
4372}
4373impl core::fmt::Debug for PhysicalDeviceDataGraphProcessingEngineTypeARM {
4374 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4375 match self.0 {
4376 0i32 => f.write_str("DEFAULT"),
4377 1000629000i32 => f.write_str("NEURAL"),
4378 1000629001i32 => f.write_str("COMPUTE"),
4379 other => {
4380 write!(
4381 f, "{}({})",
4382 stringify!(PhysicalDeviceDataGraphProcessingEngineTypeARM), other
4383 )
4384 }
4385 }
4386 }
4387}
4388#[repr(transparent)]
4390#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4391#[doc(alias = "VkPhysicalDeviceLayeredApiKHR")]
4392pub struct PhysicalDeviceLayeredApiKHR(i32);
4393impl PhysicalDeviceLayeredApiKHR {
4394 pub const VULKAN: Self = Self(0i32);
4395 pub const D3D12: Self = Self(1i32);
4396 pub const METAL: Self = Self(2i32);
4397 pub const OPENGL: Self = Self(3i32);
4398 pub const OPENGLES: Self = Self(4i32);
4399 #[inline]
4400 pub const fn from_raw(value: i32) -> Self {
4401 Self(value)
4402 }
4403 #[inline]
4404 pub const fn as_raw(self) -> i32 {
4405 self.0
4406 }
4407}
4408impl core::fmt::Debug for PhysicalDeviceLayeredApiKHR {
4409 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4410 match self.0 {
4411 0i32 => f.write_str("VULKAN"),
4412 1i32 => f.write_str("D3D12"),
4413 2i32 => f.write_str("METAL"),
4414 3i32 => f.write_str("OPENGL"),
4415 4i32 => f.write_str("OPENGLES"),
4416 other => write!(f, "{}({})", stringify!(PhysicalDeviceLayeredApiKHR), other),
4417 }
4418 }
4419}
4420#[repr(transparent)]
4422#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4423#[doc(alias = "VkPhysicalDeviceType")]
4424pub struct PhysicalDeviceType(i32);
4425impl PhysicalDeviceType {
4426 pub const OTHER: Self = Self(0i32);
4427 pub const INTEGRATED_GPU: Self = Self(1i32);
4428 pub const DISCRETE_GPU: Self = Self(2i32);
4429 pub const VIRTUAL_GPU: Self = Self(3i32);
4430 pub const CPU: Self = Self(4i32);
4431 #[inline]
4432 pub const fn from_raw(value: i32) -> Self {
4433 Self(value)
4434 }
4435 #[inline]
4436 pub const fn as_raw(self) -> i32 {
4437 self.0
4438 }
4439}
4440impl core::fmt::Debug for PhysicalDeviceType {
4441 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4442 match self.0 {
4443 0i32 => f.write_str("OTHER"),
4444 1i32 => f.write_str("INTEGRATED_GPU"),
4445 2i32 => f.write_str("DISCRETE_GPU"),
4446 3i32 => f.write_str("VIRTUAL_GPU"),
4447 4i32 => f.write_str("CPU"),
4448 other => write!(f, "{}({})", stringify!(PhysicalDeviceType), other),
4449 }
4450 }
4451}
4452#[repr(transparent)]
4454#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4455#[doc(alias = "VkPipelineBindPoint")]
4456pub struct PipelineBindPoint(i32);
4457impl PipelineBindPoint {
4458 pub const GRAPHICS: Self = Self(0i32);
4459 pub const COMPUTE: Self = Self(1i32);
4460 pub const EXECUTION_GRAPH: Self = Self(1000134000i32);
4461 pub const RAY_TRACING: Self = Self(1000165000i32);
4462 pub const SUBPASS_SHADING: Self = Self(1000369003i32);
4463 pub const DATA_GRAPH: Self = Self(1000507000i32);
4464 #[inline]
4465 pub const fn from_raw(value: i32) -> Self {
4466 Self(value)
4467 }
4468 #[inline]
4469 pub const fn as_raw(self) -> i32 {
4470 self.0
4471 }
4472}
4473impl core::fmt::Debug for PipelineBindPoint {
4474 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4475 match self.0 {
4476 0i32 => f.write_str("GRAPHICS"),
4477 1i32 => f.write_str("COMPUTE"),
4478 1000134000i32 => f.write_str("EXECUTION_GRAPH"),
4479 1000165000i32 => f.write_str("RAY_TRACING"),
4480 1000369003i32 => f.write_str("SUBPASS_SHADING"),
4481 1000507000i32 => f.write_str("DATA_GRAPH"),
4482 other => write!(f, "{}({})", stringify!(PipelineBindPoint), other),
4483 }
4484 }
4485}
4486#[repr(transparent)]
4488#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4489#[doc(alias = "VkPipelineCacheHeaderVersion")]
4490pub struct PipelineCacheHeaderVersion(i32);
4491impl PipelineCacheHeaderVersion {
4492 pub const ONE: Self = Self(1i32);
4493 pub const SAFETY_CRITICAL_ONE: Self = Self(1000298001i32);
4494 pub const DATA_GRAPH: Self = Self(1000629000i32);
4495 #[inline]
4496 pub const fn from_raw(value: i32) -> Self {
4497 Self(value)
4498 }
4499 #[inline]
4500 pub const fn as_raw(self) -> i32 {
4501 self.0
4502 }
4503}
4504impl core::fmt::Debug for PipelineCacheHeaderVersion {
4505 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4506 match self.0 {
4507 1i32 => f.write_str("ONE"),
4508 1000298001i32 => f.write_str("SAFETY_CRITICAL_ONE"),
4509 1000629000i32 => f.write_str("DATA_GRAPH"),
4510 other => write!(f, "{}({})", stringify!(PipelineCacheHeaderVersion), other),
4511 }
4512 }
4513}
4514#[repr(transparent)]
4516#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4517#[doc(alias = "VkPipelineCacheValidationVersion")]
4518pub struct PipelineCacheValidationVersion(i32);
4519impl PipelineCacheValidationVersion {
4520 pub const SAFETY_CRITICAL_ONE: Self = Self(1i32);
4521 #[inline]
4522 pub const fn from_raw(value: i32) -> Self {
4523 Self(value)
4524 }
4525 #[inline]
4526 pub const fn as_raw(self) -> i32 {
4527 self.0
4528 }
4529}
4530impl core::fmt::Debug for PipelineCacheValidationVersion {
4531 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4532 match self.0 {
4533 1i32 => f.write_str("SAFETY_CRITICAL_ONE"),
4534 other => {
4535 write!(f, "{}({})", stringify!(PipelineCacheValidationVersion), other)
4536 }
4537 }
4538 }
4539}
4540#[repr(transparent)]
4542#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4543#[doc(alias = "VkPipelineExecutableStatisticFormatKHR")]
4544pub struct PipelineExecutableStatisticFormatKHR(i32);
4545impl PipelineExecutableStatisticFormatKHR {
4546 pub const BOOL32: Self = Self(0i32);
4547 pub const INT64: Self = Self(1i32);
4548 pub const UINT64: Self = Self(2i32);
4549 pub const FLOAT64: Self = Self(3i32);
4550 #[inline]
4551 pub const fn from_raw(value: i32) -> Self {
4552 Self(value)
4553 }
4554 #[inline]
4555 pub const fn as_raw(self) -> i32 {
4556 self.0
4557 }
4558}
4559impl core::fmt::Debug for PipelineExecutableStatisticFormatKHR {
4560 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4561 match self.0 {
4562 0i32 => f.write_str("BOOL32"),
4563 1i32 => f.write_str("INT64"),
4564 2i32 => f.write_str("UINT64"),
4565 3i32 => f.write_str("FLOAT64"),
4566 other => {
4567 write!(
4568 f, "{}({})", stringify!(PipelineExecutableStatisticFormatKHR), other
4569 )
4570 }
4571 }
4572 }
4573}
4574#[repr(transparent)]
4576#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4577#[doc(alias = "VkPipelineMatchControl")]
4578pub struct PipelineMatchControl(i32);
4579impl PipelineMatchControl {
4580 pub const APPLICATION_UUID_EXACT_MATCH: Self = Self(0i32);
4581 #[inline]
4582 pub const fn from_raw(value: i32) -> Self {
4583 Self(value)
4584 }
4585 #[inline]
4586 pub const fn as_raw(self) -> i32 {
4587 self.0
4588 }
4589}
4590impl core::fmt::Debug for PipelineMatchControl {
4591 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4592 match self.0 {
4593 0i32 => f.write_str("APPLICATION_UUID_EXACT_MATCH"),
4594 other => write!(f, "{}({})", stringify!(PipelineMatchControl), other),
4595 }
4596 }
4597}
4598#[repr(transparent)]
4600#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4601#[doc(alias = "VkPipelineRobustnessBufferBehavior")]
4602pub struct PipelineRobustnessBufferBehavior(i32);
4603impl PipelineRobustnessBufferBehavior {
4604 pub const DEVICE_DEFAULT: Self = Self(0i32);
4605 pub const DISABLED: Self = Self(1i32);
4606 pub const ROBUST_BUFFER_ACCESS: Self = Self(2i32);
4607 pub const ROBUST_BUFFER_ACCESS_2: Self = Self(3i32);
4608 #[inline]
4609 pub const fn from_raw(value: i32) -> Self {
4610 Self(value)
4611 }
4612 #[inline]
4613 pub const fn as_raw(self) -> i32 {
4614 self.0
4615 }
4616}
4617impl core::fmt::Debug for PipelineRobustnessBufferBehavior {
4618 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4619 match self.0 {
4620 0i32 => f.write_str("DEVICE_DEFAULT"),
4621 1i32 => f.write_str("DISABLED"),
4622 2i32 => f.write_str("ROBUST_BUFFER_ACCESS"),
4623 3i32 => f.write_str("ROBUST_BUFFER_ACCESS_2"),
4624 other => {
4625 write!(f, "{}({})", stringify!(PipelineRobustnessBufferBehavior), other)
4626 }
4627 }
4628 }
4629}
4630#[repr(transparent)]
4632#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4633#[doc(alias = "VkPipelineRobustnessImageBehavior")]
4634pub struct PipelineRobustnessImageBehavior(i32);
4635impl PipelineRobustnessImageBehavior {
4636 pub const DEVICE_DEFAULT: Self = Self(0i32);
4637 pub const DISABLED: Self = Self(1i32);
4638 pub const ROBUST_IMAGE_ACCESS: Self = Self(2i32);
4639 pub const ROBUST_IMAGE_ACCESS_2: Self = Self(3i32);
4640 #[inline]
4641 pub const fn from_raw(value: i32) -> Self {
4642 Self(value)
4643 }
4644 #[inline]
4645 pub const fn as_raw(self) -> i32 {
4646 self.0
4647 }
4648}
4649impl core::fmt::Debug for PipelineRobustnessImageBehavior {
4650 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4651 match self.0 {
4652 0i32 => f.write_str("DEVICE_DEFAULT"),
4653 1i32 => f.write_str("DISABLED"),
4654 2i32 => f.write_str("ROBUST_IMAGE_ACCESS"),
4655 3i32 => f.write_str("ROBUST_IMAGE_ACCESS_2"),
4656 other => {
4657 write!(f, "{}({})", stringify!(PipelineRobustnessImageBehavior), other)
4658 }
4659 }
4660 }
4661}
4662#[repr(transparent)]
4664#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4665#[doc(alias = "VkPointClippingBehavior")]
4666pub struct PointClippingBehavior(i32);
4667impl PointClippingBehavior {
4668 pub const ALL_CLIP_PLANES: Self = Self(0i32);
4669 pub const USER_CLIP_PLANES_ONLY: Self = Self(1i32);
4670 #[inline]
4671 pub const fn from_raw(value: i32) -> Self {
4672 Self(value)
4673 }
4674 #[inline]
4675 pub const fn as_raw(self) -> i32 {
4676 self.0
4677 }
4678}
4679impl core::fmt::Debug for PointClippingBehavior {
4680 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4681 match self.0 {
4682 0i32 => f.write_str("ALL_CLIP_PLANES"),
4683 1i32 => f.write_str("USER_CLIP_PLANES_ONLY"),
4684 other => write!(f, "{}({})", stringify!(PointClippingBehavior), other),
4685 }
4686 }
4687}
4688#[repr(transparent)]
4690#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4691#[doc(alias = "VkPolygonMode")]
4692pub struct PolygonMode(i32);
4693impl PolygonMode {
4694 pub const FILL: Self = Self(0i32);
4695 pub const LINE: Self = Self(1i32);
4696 pub const POINT: Self = Self(2i32);
4697 pub const FILL_RECTANGLE: Self = Self(1000153000i32);
4698 #[inline]
4699 pub const fn from_raw(value: i32) -> Self {
4700 Self(value)
4701 }
4702 #[inline]
4703 pub const fn as_raw(self) -> i32 {
4704 self.0
4705 }
4706}
4707impl core::fmt::Debug for PolygonMode {
4708 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4709 match self.0 {
4710 0i32 => f.write_str("FILL"),
4711 1i32 => f.write_str("LINE"),
4712 2i32 => f.write_str("POINT"),
4713 1000153000i32 => f.write_str("FILL_RECTANGLE"),
4714 other => write!(f, "{}({})", stringify!(PolygonMode), other),
4715 }
4716 }
4717}
4718#[repr(transparent)]
4720#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4721#[doc(alias = "VkPresentModeKHR")]
4722pub struct PresentModeKHR(i32);
4723impl PresentModeKHR {
4724 pub const IMMEDIATE: Self = Self(0i32);
4725 pub const MAILBOX: Self = Self(1i32);
4726 pub const FIFO: Self = Self(2i32);
4727 pub const FIFO_RELAXED: Self = Self(3i32);
4728 pub const SHARED_DEMAND_REFRESH: Self = Self(1000111000i32);
4729 pub const SHARED_CONTINUOUS_REFRESH: Self = Self(1000111001i32);
4730 #[inline]
4731 pub const fn from_raw(value: i32) -> Self {
4732 Self(value)
4733 }
4734 #[inline]
4735 pub const fn as_raw(self) -> i32 {
4736 self.0
4737 }
4738}
4739impl core::fmt::Debug for PresentModeKHR {
4740 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4741 match self.0 {
4742 0i32 => f.write_str("IMMEDIATE"),
4743 1i32 => f.write_str("MAILBOX"),
4744 2i32 => f.write_str("FIFO"),
4745 3i32 => f.write_str("FIFO_RELAXED"),
4746 1000111000i32 => f.write_str("SHARED_DEMAND_REFRESH"),
4747 1000111001i32 => f.write_str("SHARED_CONTINUOUS_REFRESH"),
4748 other => write!(f, "{}({})", stringify!(PresentModeKHR), other),
4749 }
4750 }
4751}
4752#[repr(transparent)]
4754#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4755#[doc(alias = "VkPrimitiveTopology")]
4756pub struct PrimitiveTopology(i32);
4757impl PrimitiveTopology {
4758 pub const POINT_LIST: Self = Self(0i32);
4759 pub const LINE_LIST: Self = Self(1i32);
4760 pub const LINE_STRIP: Self = Self(2i32);
4761 pub const TRIANGLE_LIST: Self = Self(3i32);
4762 pub const TRIANGLE_STRIP: Self = Self(4i32);
4763 pub const TRIANGLE_FAN: Self = Self(5i32);
4764 pub const LINE_LIST_WITH_ADJACENCY: Self = Self(6i32);
4765 pub const LINE_STRIP_WITH_ADJACENCY: Self = Self(7i32);
4766 pub const TRIANGLE_LIST_WITH_ADJACENCY: Self = Self(8i32);
4767 pub const TRIANGLE_STRIP_WITH_ADJACENCY: Self = Self(9i32);
4768 pub const PATCH_LIST: Self = Self(10i32);
4769 #[inline]
4770 pub const fn from_raw(value: i32) -> Self {
4771 Self(value)
4772 }
4773 #[inline]
4774 pub const fn as_raw(self) -> i32 {
4775 self.0
4776 }
4777}
4778impl core::fmt::Debug for PrimitiveTopology {
4779 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4780 match self.0 {
4781 0i32 => f.write_str("POINT_LIST"),
4782 1i32 => f.write_str("LINE_LIST"),
4783 2i32 => f.write_str("LINE_STRIP"),
4784 3i32 => f.write_str("TRIANGLE_LIST"),
4785 4i32 => f.write_str("TRIANGLE_STRIP"),
4786 5i32 => f.write_str("TRIANGLE_FAN"),
4787 6i32 => f.write_str("LINE_LIST_WITH_ADJACENCY"),
4788 7i32 => f.write_str("LINE_STRIP_WITH_ADJACENCY"),
4789 8i32 => f.write_str("TRIANGLE_LIST_WITH_ADJACENCY"),
4790 9i32 => f.write_str("TRIANGLE_STRIP_WITH_ADJACENCY"),
4791 10i32 => f.write_str("PATCH_LIST"),
4792 other => write!(f, "{}({})", stringify!(PrimitiveTopology), other),
4793 }
4794 }
4795}
4796#[repr(transparent)]
4798#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4799#[doc(alias = "VkProvokingVertexModeEXT")]
4800pub struct ProvokingVertexModeEXT(i32);
4801impl ProvokingVertexModeEXT {
4802 pub const FIRST_VERTEX: Self = Self(0i32);
4803 pub const LAST_VERTEX: Self = Self(1i32);
4804 #[inline]
4805 pub const fn from_raw(value: i32) -> Self {
4806 Self(value)
4807 }
4808 #[inline]
4809 pub const fn as_raw(self) -> i32 {
4810 self.0
4811 }
4812}
4813impl core::fmt::Debug for ProvokingVertexModeEXT {
4814 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4815 match self.0 {
4816 0i32 => f.write_str("FIRST_VERTEX"),
4817 1i32 => f.write_str("LAST_VERTEX"),
4818 other => write!(f, "{}({})", stringify!(ProvokingVertexModeEXT), other),
4819 }
4820 }
4821}
4822#[repr(transparent)]
4824#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4825#[doc(alias = "VkQueryPoolSamplingModeINTEL")]
4826pub struct QueryPoolSamplingModeINTEL(i32);
4827impl QueryPoolSamplingModeINTEL {
4828 pub const MANUAL: Self = Self(0i32);
4829 #[inline]
4830 pub const fn from_raw(value: i32) -> Self {
4831 Self(value)
4832 }
4833 #[inline]
4834 pub const fn as_raw(self) -> i32 {
4835 self.0
4836 }
4837}
4838impl core::fmt::Debug for QueryPoolSamplingModeINTEL {
4839 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4840 match self.0 {
4841 0i32 => f.write_str("MANUAL"),
4842 other => write!(f, "{}({})", stringify!(QueryPoolSamplingModeINTEL), other),
4843 }
4844 }
4845}
4846#[repr(transparent)]
4848#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4849#[doc(alias = "VkQueryResultStatusKHR")]
4850pub struct QueryResultStatusKHR(i32);
4851impl QueryResultStatusKHR {
4852 pub const ERROR: Self = Self(-1i32);
4853 pub const NOT_READY: Self = Self(0i32);
4854 pub const COMPLETE: Self = Self(1i32);
4855 pub const INSUFFICIENT_BITSTREAM_BUFFER_RANGE: Self = Self(-1000299000i32);
4856 #[inline]
4857 pub const fn from_raw(value: i32) -> Self {
4858 Self(value)
4859 }
4860 #[inline]
4861 pub const fn as_raw(self) -> i32 {
4862 self.0
4863 }
4864}
4865impl core::fmt::Debug for QueryResultStatusKHR {
4866 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4867 match self.0 {
4868 -1i32 => f.write_str("ERROR"),
4869 0i32 => f.write_str("NOT_READY"),
4870 1i32 => f.write_str("COMPLETE"),
4871 -1000299000i32 => f.write_str("INSUFFICIENT_BITSTREAM_BUFFER_RANGE"),
4872 other => write!(f, "{}({})", stringify!(QueryResultStatusKHR), other),
4873 }
4874 }
4875}
4876#[repr(transparent)]
4878#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4879#[doc(alias = "VkQueryType")]
4880pub struct QueryType(i32);
4881impl QueryType {
4882 pub const OCCLUSION: Self = Self(0i32);
4883 pub const PIPELINE_STATISTICS: Self = Self(1i32);
4885 pub const TIMESTAMP: Self = Self(2i32);
4886 pub const RESULT_STATUS_ONLY: Self = Self(1000023000i32);
4887 pub const TRANSFORM_FEEDBACK_STREAM: Self = Self(1000028004i32);
4888 pub const PERFORMANCE_QUERY: Self = Self(1000116000i32);
4889 pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE: Self = Self(1000150000i32);
4890 pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE: Self = Self(1000150001i32);
4891 pub const VIDEO_ENCODE_FEEDBACK: Self = Self(1000299000i32);
4892 pub const MESH_PRIMITIVES_GENERATED: Self = Self(1000328000i32);
4893 pub const PRIMITIVES_GENERATED: Self = Self(1000382000i32);
4894 pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS: Self = Self(
4895 1000386000i32,
4896 );
4897 pub const ACCELERATION_STRUCTURE_SIZE: Self = Self(1000386001i32);
4898 pub const MICROMAP_SERIALIZATION_SIZE: Self = Self(1000396000i32);
4899 pub const MICROMAP_COMPACTED_SIZE: Self = Self(1000396001i32);
4900 #[inline]
4901 pub const fn from_raw(value: i32) -> Self {
4902 Self(value)
4903 }
4904 #[inline]
4905 pub const fn as_raw(self) -> i32 {
4906 self.0
4907 }
4908}
4909impl core::fmt::Debug for QueryType {
4910 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4911 match self.0 {
4912 0i32 => f.write_str("OCCLUSION"),
4913 1i32 => f.write_str("PIPELINE_STATISTICS"),
4914 2i32 => f.write_str("TIMESTAMP"),
4915 1000023000i32 => f.write_str("RESULT_STATUS_ONLY"),
4916 1000028004i32 => f.write_str("TRANSFORM_FEEDBACK_STREAM"),
4917 1000116000i32 => f.write_str("PERFORMANCE_QUERY"),
4918 1000150000i32 => f.write_str("ACCELERATION_STRUCTURE_COMPACTED_SIZE"),
4919 1000150001i32 => f.write_str("ACCELERATION_STRUCTURE_SERIALIZATION_SIZE"),
4920 1000299000i32 => f.write_str("VIDEO_ENCODE_FEEDBACK"),
4921 1000328000i32 => f.write_str("MESH_PRIMITIVES_GENERATED"),
4922 1000382000i32 => f.write_str("PRIMITIVES_GENERATED"),
4923 1000386000i32 => {
4924 f.write_str("ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS")
4925 }
4926 1000386001i32 => f.write_str("ACCELERATION_STRUCTURE_SIZE"),
4927 1000396000i32 => f.write_str("MICROMAP_SERIALIZATION_SIZE"),
4928 1000396001i32 => f.write_str("MICROMAP_COMPACTED_SIZE"),
4929 other => write!(f, "{}({})", stringify!(QueryType), other),
4930 }
4931 }
4932}
4933#[repr(transparent)]
4935#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4936#[doc(alias = "VkQueueGlobalPriority")]
4937pub struct QueueGlobalPriority(i32);
4938impl QueueGlobalPriority {
4939 pub const LOW: Self = Self(128i32);
4940 pub const MEDIUM: Self = Self(256i32);
4941 pub const HIGH: Self = Self(512i32);
4942 pub const REALTIME: Self = Self(1024i32);
4943 #[inline]
4944 pub const fn from_raw(value: i32) -> Self {
4945 Self(value)
4946 }
4947 #[inline]
4948 pub const fn as_raw(self) -> i32 {
4949 self.0
4950 }
4951}
4952impl core::fmt::Debug for QueueGlobalPriority {
4953 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4954 match self.0 {
4955 128i32 => f.write_str("LOW"),
4956 256i32 => f.write_str("MEDIUM"),
4957 512i32 => f.write_str("HIGH"),
4958 1024i32 => f.write_str("REALTIME"),
4959 other => write!(f, "{}({})", stringify!(QueueGlobalPriority), other),
4960 }
4961 }
4962}
4963#[repr(transparent)]
4965#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4966#[doc(alias = "VkRasterizationOrderAMD")]
4967pub struct RasterizationOrderAMD(i32);
4968impl RasterizationOrderAMD {
4969 pub const STRICT: Self = Self(0i32);
4970 pub const RELAXED: Self = Self(1i32);
4971 #[inline]
4972 pub const fn from_raw(value: i32) -> Self {
4973 Self(value)
4974 }
4975 #[inline]
4976 pub const fn as_raw(self) -> i32 {
4977 self.0
4978 }
4979}
4980impl core::fmt::Debug for RasterizationOrderAMD {
4981 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4982 match self.0 {
4983 0i32 => f.write_str("STRICT"),
4984 1i32 => f.write_str("RELAXED"),
4985 other => write!(f, "{}({})", stringify!(RasterizationOrderAMD), other),
4986 }
4987 }
4988}
4989#[repr(transparent)]
4991#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4992#[doc(alias = "VkRayTracingInvocationReorderModeEXT")]
4993pub struct RayTracingInvocationReorderModeEXT(i32);
4994impl RayTracingInvocationReorderModeEXT {
4995 pub const NONE: Self = Self(0i32);
4996 pub const REORDER: Self = Self(1i32);
4997 #[inline]
4998 pub const fn from_raw(value: i32) -> Self {
4999 Self(value)
5000 }
5001 #[inline]
5002 pub const fn as_raw(self) -> i32 {
5003 self.0
5004 }
5005}
5006impl core::fmt::Debug for RayTracingInvocationReorderModeEXT {
5007 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5008 match self.0 {
5009 0i32 => f.write_str("NONE"),
5010 1i32 => f.write_str("REORDER"),
5011 other => {
5012 write!(
5013 f, "{}({})", stringify!(RayTracingInvocationReorderModeEXT), other
5014 )
5015 }
5016 }
5017 }
5018}
5019#[repr(transparent)]
5021#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5022#[doc(alias = "VkRayTracingLssIndexingModeNV")]
5023pub struct RayTracingLssIndexingModeNV(i32);
5024impl RayTracingLssIndexingModeNV {
5025 pub const LIST: Self = Self(0i32);
5026 pub const SUCCESSIVE: Self = Self(1i32);
5027 #[inline]
5028 pub const fn from_raw(value: i32) -> Self {
5029 Self(value)
5030 }
5031 #[inline]
5032 pub const fn as_raw(self) -> i32 {
5033 self.0
5034 }
5035}
5036impl core::fmt::Debug for RayTracingLssIndexingModeNV {
5037 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5038 match self.0 {
5039 0i32 => f.write_str("LIST"),
5040 1i32 => f.write_str("SUCCESSIVE"),
5041 other => write!(f, "{}({})", stringify!(RayTracingLssIndexingModeNV), other),
5042 }
5043 }
5044}
5045#[repr(transparent)]
5047#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5048#[doc(alias = "VkRayTracingLssPrimitiveEndCapsModeNV")]
5049pub struct RayTracingLssPrimitiveEndCapsModeNV(i32);
5050impl RayTracingLssPrimitiveEndCapsModeNV {
5051 pub const NONE: Self = Self(0i32);
5052 pub const CHAINED: Self = Self(1i32);
5053 #[inline]
5054 pub const fn from_raw(value: i32) -> Self {
5055 Self(value)
5056 }
5057 #[inline]
5058 pub const fn as_raw(self) -> i32 {
5059 self.0
5060 }
5061}
5062impl core::fmt::Debug for RayTracingLssPrimitiveEndCapsModeNV {
5063 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5064 match self.0 {
5065 0i32 => f.write_str("NONE"),
5066 1i32 => f.write_str("CHAINED"),
5067 other => {
5068 write!(
5069 f, "{}({})", stringify!(RayTracingLssPrimitiveEndCapsModeNV), other
5070 )
5071 }
5072 }
5073 }
5074}
5075#[repr(transparent)]
5077#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5078#[doc(alias = "VkRayTracingShaderGroupTypeKHR")]
5079pub struct RayTracingShaderGroupTypeKHR(i32);
5080impl RayTracingShaderGroupTypeKHR {
5081 pub const GENERAL: Self = Self(0i32);
5082 pub const TRIANGLES_HIT_GROUP: Self = Self(1i32);
5083 pub const PROCEDURAL_HIT_GROUP: Self = Self(2i32);
5084 #[inline]
5085 pub const fn from_raw(value: i32) -> Self {
5086 Self(value)
5087 }
5088 #[inline]
5089 pub const fn as_raw(self) -> i32 {
5090 self.0
5091 }
5092}
5093impl core::fmt::Debug for RayTracingShaderGroupTypeKHR {
5094 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5095 match self.0 {
5096 0i32 => f.write_str("GENERAL"),
5097 1i32 => f.write_str("TRIANGLES_HIT_GROUP"),
5098 2i32 => f.write_str("PROCEDURAL_HIT_GROUP"),
5099 other => write!(f, "{}({})", stringify!(RayTracingShaderGroupTypeKHR), other),
5100 }
5101 }
5102}
5103#[repr(transparent)]
5105#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5106#[doc(alias = "VkResult")]
5107pub struct Result(i32);
5108impl Result {
5109 pub const SUCCESS: Self = Self(0i32);
5111 pub const NOT_READY: Self = Self(1i32);
5113 pub const TIMEOUT: Self = Self(2i32);
5115 pub const EVENT_SET: Self = Self(3i32);
5117 pub const EVENT_RESET: Self = Self(4i32);
5119 pub const INCOMPLETE: Self = Self(5i32);
5121 pub const ERROR_OUT_OF_HOST_MEMORY: Self = Self(-1i32);
5123 pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Self(-2i32);
5125 pub const ERROR_INITIALIZATION_FAILED: Self = Self(-3i32);
5127 pub const ERROR_DEVICE_LOST: Self = Self(-4i32);
5129 pub const ERROR_MEMORY_MAP_FAILED: Self = Self(-5i32);
5131 pub const ERROR_LAYER_NOT_PRESENT: Self = Self(-6i32);
5133 pub const ERROR_EXTENSION_NOT_PRESENT: Self = Self(-7i32);
5135 pub const ERROR_FEATURE_NOT_PRESENT: Self = Self(-8i32);
5137 pub const ERROR_INCOMPATIBLE_DRIVER: Self = Self(-9i32);
5139 pub const ERROR_TOO_MANY_OBJECTS: Self = Self(-10i32);
5141 pub const ERROR_FORMAT_NOT_SUPPORTED: Self = Self(-11i32);
5143 pub const ERROR_FRAGMENTED_POOL: Self = Self(-12i32);
5145 pub const ERROR_UNKNOWN: Self = Self(-13i32);
5147 pub const ERROR_VALIDATION_FAILED: Self = Self(-1000011001i32);
5148 pub const ERROR_OUT_OF_POOL_MEMORY: Self = Self(-1000069000i32);
5149 pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Self(-1000072003i32);
5150 pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Self(-1000257000i32);
5151 pub const ERROR_FRAGMENTATION: Self = Self(-1000161000i32);
5152 pub const PIPELINE_COMPILE_REQUIRED: Self = Self(1000297000i32);
5153 pub const ERROR_NOT_PERMITTED: Self = Self(-1000174001i32);
5154 pub const ERROR_INVALID_PIPELINE_CACHE_DATA: Self = Self(-1000298000i32);
5155 pub const ERROR_NO_PIPELINE_MATCH: Self = Self(-1000298001i32);
5156 pub const ERROR_SURFACE_LOST: Self = Self(-1000000000i32);
5157 pub const ERROR_NATIVE_WINDOW_IN_USE: Self = Self(-1000000001i32);
5158 pub const SUBOPTIMAL: Self = Self(1000001003i32);
5159 pub const ERROR_OUT_OF_DATE: Self = Self(-1000001004i32);
5160 pub const ERROR_INCOMPATIBLE_DISPLAY: Self = Self(-1000003001i32);
5161 pub const ERROR_INVALID_SHADER: Self = Self(-1000012000i32);
5162 pub const ERROR_IMAGE_USAGE_NOT_SUPPORTED: Self = Self(-1000023000i32);
5163 pub const ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED: Self = Self(-1000023001i32);
5164 pub const ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED: Self = Self(-1000023002i32);
5165 pub const ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED: Self = Self(-1000023003i32);
5166 pub const ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED: Self = Self(-1000023004i32);
5167 pub const ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED: Self = Self(-1000023005i32);
5168 pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT: Self = Self(
5169 -1000158000i32,
5170 );
5171 pub const ERROR_PRESENT_TIMING_QUEUE_FULL: Self = Self(-1000208000i32);
5172 pub const ERROR_INVALID_DEVICE_ADDRESS: Self = Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
5173 pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST: Self = Self(-1000255000i32);
5174 pub const THREAD_IDLE: Self = Self(1000268000i32);
5175 pub const THREAD_DONE: Self = Self(1000268001i32);
5176 pub const OPERATION_DEFERRED: Self = Self(1000268002i32);
5177 pub const OPERATION_NOT_DEFERRED: Self = Self(1000268003i32);
5178 pub const ERROR_PIPELINE_COMPILE_REQUIRED: Self = Self::PIPELINE_COMPILE_REQUIRED;
5179 pub const ERROR_INVALID_VIDEO_STD_PARAMETERS: Self = Self(-1000299000i32);
5180 pub const ERROR_COMPRESSION_EXHAUSTED: Self = Self(-1000338000i32);
5181 pub const INCOMPATIBLE_SHADER_BINARY: Self = Self(1000482000i32);
5182 pub const ERROR_INCOMPATIBLE_SHADER_BINARY: Self = Self::INCOMPATIBLE_SHADER_BINARY;
5183 pub const PIPELINE_BINARY_MISSING: Self = Self(1000483000i32);
5184 pub const ERROR_NOT_ENOUGH_SPACE: Self = Self(-1000483000i32);
5185 #[inline]
5186 pub const fn from_raw(value: i32) -> Self {
5187 Self(value)
5188 }
5189 #[inline]
5190 pub const fn as_raw(self) -> i32 {
5191 self.0
5192 }
5193}
5194impl core::fmt::Debug for Result {
5195 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5196 match self.0 {
5197 0i32 => f.write_str("SUCCESS"),
5198 1i32 => f.write_str("NOT_READY"),
5199 2i32 => f.write_str("TIMEOUT"),
5200 3i32 => f.write_str("EVENT_SET"),
5201 4i32 => f.write_str("EVENT_RESET"),
5202 5i32 => f.write_str("INCOMPLETE"),
5203 -1i32 => f.write_str("ERROR_OUT_OF_HOST_MEMORY"),
5204 -2i32 => f.write_str("ERROR_OUT_OF_DEVICE_MEMORY"),
5205 -3i32 => f.write_str("ERROR_INITIALIZATION_FAILED"),
5206 -4i32 => f.write_str("ERROR_DEVICE_LOST"),
5207 -5i32 => f.write_str("ERROR_MEMORY_MAP_FAILED"),
5208 -6i32 => f.write_str("ERROR_LAYER_NOT_PRESENT"),
5209 -7i32 => f.write_str("ERROR_EXTENSION_NOT_PRESENT"),
5210 -8i32 => f.write_str("ERROR_FEATURE_NOT_PRESENT"),
5211 -9i32 => f.write_str("ERROR_INCOMPATIBLE_DRIVER"),
5212 -10i32 => f.write_str("ERROR_TOO_MANY_OBJECTS"),
5213 -11i32 => f.write_str("ERROR_FORMAT_NOT_SUPPORTED"),
5214 -12i32 => f.write_str("ERROR_FRAGMENTED_POOL"),
5215 -13i32 => f.write_str("ERROR_UNKNOWN"),
5216 -1000011001i32 => f.write_str("ERROR_VALIDATION_FAILED"),
5217 -1000069000i32 => f.write_str("ERROR_OUT_OF_POOL_MEMORY"),
5218 -1000072003i32 => f.write_str("ERROR_INVALID_EXTERNAL_HANDLE"),
5219 -1000257000i32 => f.write_str("ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"),
5220 -1000161000i32 => f.write_str("ERROR_FRAGMENTATION"),
5221 1000297000i32 => f.write_str("PIPELINE_COMPILE_REQUIRED"),
5222 -1000174001i32 => f.write_str("ERROR_NOT_PERMITTED"),
5223 -1000298000i32 => f.write_str("ERROR_INVALID_PIPELINE_CACHE_DATA"),
5224 -1000298001i32 => f.write_str("ERROR_NO_PIPELINE_MATCH"),
5225 -1000000000i32 => f.write_str("ERROR_SURFACE_LOST"),
5226 -1000000001i32 => f.write_str("ERROR_NATIVE_WINDOW_IN_USE"),
5227 1000001003i32 => f.write_str("SUBOPTIMAL"),
5228 -1000001004i32 => f.write_str("ERROR_OUT_OF_DATE"),
5229 -1000003001i32 => f.write_str("ERROR_INCOMPATIBLE_DISPLAY"),
5230 -1000012000i32 => f.write_str("ERROR_INVALID_SHADER"),
5231 -1000023000i32 => f.write_str("ERROR_IMAGE_USAGE_NOT_SUPPORTED"),
5232 -1000023001i32 => f.write_str("ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED"),
5233 -1000023002i32 => f.write_str("ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED"),
5234 -1000023003i32 => f.write_str("ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED"),
5235 -1000023004i32 => f.write_str("ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED"),
5236 -1000023005i32 => f.write_str("ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED"),
5237 -1000158000i32 => {
5238 f.write_str("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT")
5239 }
5240 -1000208000i32 => f.write_str("ERROR_PRESENT_TIMING_QUEUE_FULL"),
5241 -1000255000i32 => f.write_str("ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST"),
5242 1000268000i32 => f.write_str("THREAD_IDLE"),
5243 1000268001i32 => f.write_str("THREAD_DONE"),
5244 1000268002i32 => f.write_str("OPERATION_DEFERRED"),
5245 1000268003i32 => f.write_str("OPERATION_NOT_DEFERRED"),
5246 -1000299000i32 => f.write_str("ERROR_INVALID_VIDEO_STD_PARAMETERS"),
5247 -1000338000i32 => f.write_str("ERROR_COMPRESSION_EXHAUSTED"),
5248 1000482000i32 => f.write_str("INCOMPATIBLE_SHADER_BINARY"),
5249 1000483000i32 => f.write_str("PIPELINE_BINARY_MISSING"),
5250 -1000483000i32 => f.write_str("ERROR_NOT_ENOUGH_SPACE"),
5251 other => write!(f, "{}({})", stringify!(Result), other),
5252 }
5253 }
5254}
5255#[repr(transparent)]
5257#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5258#[doc(alias = "VkSamplerAddressMode")]
5259pub struct SamplerAddressMode(i32);
5260impl SamplerAddressMode {
5261 pub const REPEAT: Self = Self(0i32);
5262 pub const MIRRORED_REPEAT: Self = Self(1i32);
5263 pub const CLAMP_TO_EDGE: Self = Self(2i32);
5264 pub const CLAMP_TO_BORDER: Self = Self(3i32);
5265 pub const MIRROR_CLAMP_TO_EDGE: Self = Self(4i32);
5267 #[inline]
5268 pub const fn from_raw(value: i32) -> Self {
5269 Self(value)
5270 }
5271 #[inline]
5272 pub const fn as_raw(self) -> i32 {
5273 self.0
5274 }
5275}
5276impl core::fmt::Debug for SamplerAddressMode {
5277 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5278 match self.0 {
5279 0i32 => f.write_str("REPEAT"),
5280 1i32 => f.write_str("MIRRORED_REPEAT"),
5281 2i32 => f.write_str("CLAMP_TO_EDGE"),
5282 3i32 => f.write_str("CLAMP_TO_BORDER"),
5283 4i32 => f.write_str("MIRROR_CLAMP_TO_EDGE"),
5284 other => write!(f, "{}({})", stringify!(SamplerAddressMode), other),
5285 }
5286 }
5287}
5288#[repr(transparent)]
5290#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5291#[doc(alias = "VkSamplerMipmapMode")]
5292pub struct SamplerMipmapMode(i32);
5293impl SamplerMipmapMode {
5294 pub const NEAREST: Self = Self(0i32);
5296 pub const LINEAR: Self = Self(1i32);
5298 #[inline]
5299 pub const fn from_raw(value: i32) -> Self {
5300 Self(value)
5301 }
5302 #[inline]
5303 pub const fn as_raw(self) -> i32 {
5304 self.0
5305 }
5306}
5307impl core::fmt::Debug for SamplerMipmapMode {
5308 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5309 match self.0 {
5310 0i32 => f.write_str("NEAREST"),
5311 1i32 => f.write_str("LINEAR"),
5312 other => write!(f, "{}({})", stringify!(SamplerMipmapMode), other),
5313 }
5314 }
5315}
5316#[repr(transparent)]
5318#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5319#[doc(alias = "VkSamplerReductionMode")]
5320pub struct SamplerReductionMode(i32);
5321impl SamplerReductionMode {
5322 pub const WEIGHTED_AVERAGE: Self = Self(0i32);
5323 pub const MIN: Self = Self(1i32);
5324 pub const MAX: Self = Self(2i32);
5325 pub const WEIGHTED_AVERAGE_RANGECLAMP: Self = Self(1000521000i32);
5326 #[inline]
5327 pub const fn from_raw(value: i32) -> Self {
5328 Self(value)
5329 }
5330 #[inline]
5331 pub const fn as_raw(self) -> i32 {
5332 self.0
5333 }
5334}
5335impl core::fmt::Debug for SamplerReductionMode {
5336 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5337 match self.0 {
5338 0i32 => f.write_str("WEIGHTED_AVERAGE"),
5339 1i32 => f.write_str("MIN"),
5340 2i32 => f.write_str("MAX"),
5341 1000521000i32 => f.write_str("WEIGHTED_AVERAGE_RANGECLAMP"),
5342 other => write!(f, "{}({})", stringify!(SamplerReductionMode), other),
5343 }
5344 }
5345}
5346#[repr(transparent)]
5348#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5349#[doc(alias = "VkSamplerYcbcrModelConversion")]
5350pub struct SamplerYcbcrModelConversion(i32);
5351impl SamplerYcbcrModelConversion {
5352 pub const RGB_IDENTITY: Self = Self(0i32);
5353 pub const YCBCR_IDENTITY: Self = Self(1i32);
5355 pub const YCBCR_709: Self = Self(2i32);
5357 pub const YCBCR_601: Self = Self(3i32);
5359 pub const YCBCR_2020: Self = Self(4i32);
5361 #[inline]
5362 pub const fn from_raw(value: i32) -> Self {
5363 Self(value)
5364 }
5365 #[inline]
5366 pub const fn as_raw(self) -> i32 {
5367 self.0
5368 }
5369}
5370impl core::fmt::Debug for SamplerYcbcrModelConversion {
5371 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5372 match self.0 {
5373 0i32 => f.write_str("RGB_IDENTITY"),
5374 1i32 => f.write_str("YCBCR_IDENTITY"),
5375 2i32 => f.write_str("YCBCR_709"),
5376 3i32 => f.write_str("YCBCR_601"),
5377 4i32 => f.write_str("YCBCR_2020"),
5378 other => write!(f, "{}({})", stringify!(SamplerYcbcrModelConversion), other),
5379 }
5380 }
5381}
5382#[repr(transparent)]
5384#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5385#[doc(alias = "VkSamplerYcbcrRange")]
5386pub struct SamplerYcbcrRange(i32);
5387impl SamplerYcbcrRange {
5388 pub const ITU_FULL: Self = Self(0i32);
5390 pub const ITU_NARROW: Self = Self(1i32);
5392 #[inline]
5393 pub const fn from_raw(value: i32) -> Self {
5394 Self(value)
5395 }
5396 #[inline]
5397 pub const fn as_raw(self) -> i32 {
5398 self.0
5399 }
5400}
5401impl core::fmt::Debug for SamplerYcbcrRange {
5402 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5403 match self.0 {
5404 0i32 => f.write_str("ITU_FULL"),
5405 1i32 => f.write_str("ITU_NARROW"),
5406 other => write!(f, "{}({})", stringify!(SamplerYcbcrRange), other),
5407 }
5408 }
5409}
5410#[repr(transparent)]
5412#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5413#[doc(alias = "VkSciSyncClientTypeNV")]
5414pub struct SciSyncClientTypeNV(i32);
5415impl SciSyncClientTypeNV {
5416 pub const SIGNALER: Self = Self(0i32);
5417 pub const WAITER: Self = Self(1i32);
5418 pub const SIGNALER_WAITER: Self = Self(2i32);
5419 #[inline]
5420 pub const fn from_raw(value: i32) -> Self {
5421 Self(value)
5422 }
5423 #[inline]
5424 pub const fn as_raw(self) -> i32 {
5425 self.0
5426 }
5427}
5428impl core::fmt::Debug for SciSyncClientTypeNV {
5429 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5430 match self.0 {
5431 0i32 => f.write_str("SIGNALER"),
5432 1i32 => f.write_str("WAITER"),
5433 2i32 => f.write_str("SIGNALER_WAITER"),
5434 other => write!(f, "{}({})", stringify!(SciSyncClientTypeNV), other),
5435 }
5436 }
5437}
5438#[repr(transparent)]
5440#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5441#[doc(alias = "VkSciSyncPrimitiveTypeNV")]
5442pub struct SciSyncPrimitiveTypeNV(i32);
5443impl SciSyncPrimitiveTypeNV {
5444 pub const FENCE: Self = Self(0i32);
5445 pub const SEMAPHORE: Self = Self(1i32);
5446 #[inline]
5447 pub const fn from_raw(value: i32) -> Self {
5448 Self(value)
5449 }
5450 #[inline]
5451 pub const fn as_raw(self) -> i32 {
5452 self.0
5453 }
5454}
5455impl core::fmt::Debug for SciSyncPrimitiveTypeNV {
5456 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5457 match self.0 {
5458 0i32 => f.write_str("FENCE"),
5459 1i32 => f.write_str("SEMAPHORE"),
5460 other => write!(f, "{}({})", stringify!(SciSyncPrimitiveTypeNV), other),
5461 }
5462 }
5463}
5464#[repr(transparent)]
5466#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5467#[doc(alias = "VkScopeKHR")]
5468pub struct ScopeKHR(i32);
5469impl ScopeKHR {
5470 pub const DEVICE: Self = Self(1i32);
5471 pub const WORKGROUP: Self = Self(2i32);
5472 pub const SUBGROUP: Self = Self(3i32);
5473 pub const QUEUE_FAMILY: Self = Self(5i32);
5474 #[inline]
5475 pub const fn from_raw(value: i32) -> Self {
5476 Self(value)
5477 }
5478 #[inline]
5479 pub const fn as_raw(self) -> i32 {
5480 self.0
5481 }
5482}
5483impl core::fmt::Debug for ScopeKHR {
5484 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5485 match self.0 {
5486 1i32 => f.write_str("DEVICE"),
5487 2i32 => f.write_str("WORKGROUP"),
5488 3i32 => f.write_str("SUBGROUP"),
5489 5i32 => f.write_str("QUEUE_FAMILY"),
5490 other => write!(f, "{}({})", stringify!(ScopeKHR), other),
5491 }
5492 }
5493}
5494#[repr(transparent)]
5496#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5497#[doc(alias = "VkSemaphoreType")]
5498pub struct SemaphoreType(i32);
5499impl SemaphoreType {
5500 pub const BINARY: Self = Self(0i32);
5501 pub const TIMELINE: Self = Self(1i32);
5502 #[inline]
5503 pub const fn from_raw(value: i32) -> Self {
5504 Self(value)
5505 }
5506 #[inline]
5507 pub const fn as_raw(self) -> i32 {
5508 self.0
5509 }
5510}
5511impl core::fmt::Debug for SemaphoreType {
5512 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5513 match self.0 {
5514 0i32 => f.write_str("BINARY"),
5515 1i32 => f.write_str("TIMELINE"),
5516 other => write!(f, "{}({})", stringify!(SemaphoreType), other),
5517 }
5518 }
5519}
5520#[repr(transparent)]
5522#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5523#[doc(alias = "VkShaderCodeTypeEXT")]
5524pub struct ShaderCodeTypeEXT(i32);
5525impl ShaderCodeTypeEXT {
5526 pub const BINARY: Self = Self(0i32);
5527 pub const SPIRV: Self = Self(1i32);
5528 #[inline]
5529 pub const fn from_raw(value: i32) -> Self {
5530 Self(value)
5531 }
5532 #[inline]
5533 pub const fn as_raw(self) -> i32 {
5534 self.0
5535 }
5536}
5537impl core::fmt::Debug for ShaderCodeTypeEXT {
5538 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5539 match self.0 {
5540 0i32 => f.write_str("BINARY"),
5541 1i32 => f.write_str("SPIRV"),
5542 other => write!(f, "{}({})", stringify!(ShaderCodeTypeEXT), other),
5543 }
5544 }
5545}
5546#[repr(transparent)]
5548#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5549#[doc(alias = "VkShaderFloatControlsIndependence")]
5550pub struct ShaderFloatControlsIndependence(i32);
5551impl ShaderFloatControlsIndependence {
5552 pub const _32_BIT_ONLY: Self = Self(0i32);
5553 pub const ALL: Self = Self(1i32);
5554 pub const NONE: Self = Self(2i32);
5555 #[inline]
5556 pub const fn from_raw(value: i32) -> Self {
5557 Self(value)
5558 }
5559 #[inline]
5560 pub const fn as_raw(self) -> i32 {
5561 self.0
5562 }
5563}
5564impl core::fmt::Debug for ShaderFloatControlsIndependence {
5565 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5566 match self.0 {
5567 0i32 => f.write_str("_32_BIT_ONLY"),
5568 1i32 => f.write_str("ALL"),
5569 2i32 => f.write_str("NONE"),
5570 other => {
5571 write!(f, "{}({})", stringify!(ShaderFloatControlsIndependence), other)
5572 }
5573 }
5574 }
5575}
5576#[repr(transparent)]
5578#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5579#[doc(alias = "VkShaderGroupShaderKHR")]
5580pub struct ShaderGroupShaderKHR(i32);
5581impl ShaderGroupShaderKHR {
5582 pub const GENERAL: Self = Self(0i32);
5583 pub const CLOSEST_HIT: Self = Self(1i32);
5584 pub const ANY_HIT: Self = Self(2i32);
5585 pub const INTERSECTION: Self = Self(3i32);
5586 #[inline]
5587 pub const fn from_raw(value: i32) -> Self {
5588 Self(value)
5589 }
5590 #[inline]
5591 pub const fn as_raw(self) -> i32 {
5592 self.0
5593 }
5594}
5595impl core::fmt::Debug for ShaderGroupShaderKHR {
5596 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5597 match self.0 {
5598 0i32 => f.write_str("GENERAL"),
5599 1i32 => f.write_str("CLOSEST_HIT"),
5600 2i32 => f.write_str("ANY_HIT"),
5601 3i32 => f.write_str("INTERSECTION"),
5602 other => write!(f, "{}({})", stringify!(ShaderGroupShaderKHR), other),
5603 }
5604 }
5605}
5606#[repr(transparent)]
5608#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5609#[doc(alias = "VkShaderInfoTypeAMD")]
5610pub struct ShaderInfoTypeAMD(i32);
5611impl ShaderInfoTypeAMD {
5612 pub const STATISTICS: Self = Self(0i32);
5613 pub const BINARY: Self = Self(1i32);
5614 pub const DISASSEMBLY: Self = Self(2i32);
5615 #[inline]
5616 pub const fn from_raw(value: i32) -> Self {
5617 Self(value)
5618 }
5619 #[inline]
5620 pub const fn as_raw(self) -> i32 {
5621 self.0
5622 }
5623}
5624impl core::fmt::Debug for ShaderInfoTypeAMD {
5625 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5626 match self.0 {
5627 0i32 => f.write_str("STATISTICS"),
5628 1i32 => f.write_str("BINARY"),
5629 2i32 => f.write_str("DISASSEMBLY"),
5630 other => write!(f, "{}({})", stringify!(ShaderInfoTypeAMD), other),
5631 }
5632 }
5633}
5634#[repr(transparent)]
5636#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5637#[doc(alias = "VkShadingRatePaletteEntryNV")]
5638pub struct ShadingRatePaletteEntryNV(i32);
5639impl ShadingRatePaletteEntryNV {
5640 pub const NO_INVOCATIONS: Self = Self(0i32);
5641 pub const _16_INVOCATIONS_PER_PIXEL: Self = Self(1i32);
5642 pub const _8_INVOCATIONS_PER_PIXEL: Self = Self(2i32);
5643 pub const _4_INVOCATIONS_PER_PIXEL: Self = Self(3i32);
5644 pub const _2_INVOCATIONS_PER_PIXEL: Self = Self(4i32);
5645 pub const _1_INVOCATION_PER_PIXEL: Self = Self(5i32);
5646 pub const _1_INVOCATION_PER_2X1_PIXELS: Self = Self(6i32);
5647 pub const _1_INVOCATION_PER_1X2_PIXELS: Self = Self(7i32);
5648 pub const _1_INVOCATION_PER_2X2_PIXELS: Self = Self(8i32);
5649 pub const _1_INVOCATION_PER_4X2_PIXELS: Self = Self(9i32);
5650 pub const _1_INVOCATION_PER_2X4_PIXELS: Self = Self(10i32);
5651 pub const _1_INVOCATION_PER_4X4_PIXELS: Self = Self(11i32);
5652 #[inline]
5653 pub const fn from_raw(value: i32) -> Self {
5654 Self(value)
5655 }
5656 #[inline]
5657 pub const fn as_raw(self) -> i32 {
5658 self.0
5659 }
5660}
5661impl core::fmt::Debug for ShadingRatePaletteEntryNV {
5662 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5663 match self.0 {
5664 0i32 => f.write_str("NO_INVOCATIONS"),
5665 1i32 => f.write_str("_16_INVOCATIONS_PER_PIXEL"),
5666 2i32 => f.write_str("_8_INVOCATIONS_PER_PIXEL"),
5667 3i32 => f.write_str("_4_INVOCATIONS_PER_PIXEL"),
5668 4i32 => f.write_str("_2_INVOCATIONS_PER_PIXEL"),
5669 5i32 => f.write_str("_1_INVOCATION_PER_PIXEL"),
5670 6i32 => f.write_str("_1_INVOCATION_PER_2X1_PIXELS"),
5671 7i32 => f.write_str("_1_INVOCATION_PER_1X2_PIXELS"),
5672 8i32 => f.write_str("_1_INVOCATION_PER_2X2_PIXELS"),
5673 9i32 => f.write_str("_1_INVOCATION_PER_4X2_PIXELS"),
5674 10i32 => f.write_str("_1_INVOCATION_PER_2X4_PIXELS"),
5675 11i32 => f.write_str("_1_INVOCATION_PER_4X4_PIXELS"),
5676 other => write!(f, "{}({})", stringify!(ShadingRatePaletteEntryNV), other),
5677 }
5678 }
5679}
5680#[repr(transparent)]
5682#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5683#[doc(alias = "VkSharingMode")]
5684pub struct SharingMode(i32);
5685impl SharingMode {
5686 pub const EXCLUSIVE: Self = Self(0i32);
5687 pub const CONCURRENT: Self = Self(1i32);
5688 #[inline]
5689 pub const fn from_raw(value: i32) -> Self {
5690 Self(value)
5691 }
5692 #[inline]
5693 pub const fn as_raw(self) -> i32 {
5694 self.0
5695 }
5696}
5697impl core::fmt::Debug for SharingMode {
5698 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5699 match self.0 {
5700 0i32 => f.write_str("EXCLUSIVE"),
5701 1i32 => f.write_str("CONCURRENT"),
5702 other => write!(f, "{}({})", stringify!(SharingMode), other),
5703 }
5704 }
5705}
5706#[repr(transparent)]
5708#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5709#[doc(alias = "VkStencilOp")]
5710pub struct StencilOp(i32);
5711impl StencilOp {
5712 pub const KEEP: Self = Self(0i32);
5713 pub const ZERO: Self = Self(1i32);
5714 pub const REPLACE: Self = Self(2i32);
5715 pub const INCREMENT_AND_CLAMP: Self = Self(3i32);
5716 pub const DECREMENT_AND_CLAMP: Self = Self(4i32);
5717 pub const INVERT: Self = Self(5i32);
5718 pub const INCREMENT_AND_WRAP: Self = Self(6i32);
5719 pub const DECREMENT_AND_WRAP: Self = Self(7i32);
5720 #[inline]
5721 pub const fn from_raw(value: i32) -> Self {
5722 Self(value)
5723 }
5724 #[inline]
5725 pub const fn as_raw(self) -> i32 {
5726 self.0
5727 }
5728}
5729impl core::fmt::Debug for StencilOp {
5730 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5731 match self.0 {
5732 0i32 => f.write_str("KEEP"),
5733 1i32 => f.write_str("ZERO"),
5734 2i32 => f.write_str("REPLACE"),
5735 3i32 => f.write_str("INCREMENT_AND_CLAMP"),
5736 4i32 => f.write_str("DECREMENT_AND_CLAMP"),
5737 5i32 => f.write_str("INVERT"),
5738 6i32 => f.write_str("INCREMENT_AND_WRAP"),
5739 7i32 => f.write_str("DECREMENT_AND_WRAP"),
5740 other => write!(f, "{}({})", stringify!(StencilOp), other),
5741 }
5742 }
5743}
5744#[repr(transparent)]
5746#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5747#[doc(alias = "VkStructureType")]
5748pub struct StructureType(i32);
5749impl StructureType {
5750 pub const APPLICATION_INFO: Self = Self(0i32);
5751 pub const INSTANCE_CREATE_INFO: Self = Self(1i32);
5752 pub const DEVICE_QUEUE_CREATE_INFO: Self = Self(2i32);
5753 pub const DEVICE_CREATE_INFO: Self = Self(3i32);
5754 pub const SUBMIT_INFO: Self = Self(4i32);
5755 pub const MEMORY_ALLOCATE_INFO: Self = Self(5i32);
5756 pub const MAPPED_MEMORY_RANGE: Self = Self(6i32);
5757 pub const BIND_SPARSE_INFO: Self = Self(7i32);
5758 pub const FENCE_CREATE_INFO: Self = Self(8i32);
5759 pub const SEMAPHORE_CREATE_INFO: Self = Self(9i32);
5760 pub const EVENT_CREATE_INFO: Self = Self(10i32);
5761 pub const QUERY_POOL_CREATE_INFO: Self = Self(11i32);
5762 pub const BUFFER_CREATE_INFO: Self = Self(12i32);
5763 pub const BUFFER_VIEW_CREATE_INFO: Self = Self(13i32);
5764 pub const IMAGE_CREATE_INFO: Self = Self(14i32);
5765 pub const IMAGE_VIEW_CREATE_INFO: Self = Self(15i32);
5766 pub const SHADER_MODULE_CREATE_INFO: Self = Self(16i32);
5767 pub const PIPELINE_CACHE_CREATE_INFO: Self = Self(17i32);
5768 pub const PIPELINE_SHADER_STAGE_CREATE_INFO: Self = Self(18i32);
5769 pub const PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: Self = Self(19i32);
5770 pub const PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: Self = Self(20i32);
5771 pub const PIPELINE_TESSELLATION_STATE_CREATE_INFO: Self = Self(21i32);
5772 pub const PIPELINE_VIEWPORT_STATE_CREATE_INFO: Self = Self(22i32);
5773 pub const PIPELINE_RASTERIZATION_STATE_CREATE_INFO: Self = Self(23i32);
5774 pub const PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: Self = Self(24i32);
5775 pub const PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: Self = Self(25i32);
5776 pub const PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: Self = Self(26i32);
5777 pub const PIPELINE_DYNAMIC_STATE_CREATE_INFO: Self = Self(27i32);
5778 pub const GRAPHICS_PIPELINE_CREATE_INFO: Self = Self(28i32);
5779 pub const COMPUTE_PIPELINE_CREATE_INFO: Self = Self(29i32);
5780 pub const PIPELINE_LAYOUT_CREATE_INFO: Self = Self(30i32);
5781 pub const SAMPLER_CREATE_INFO: Self = Self(31i32);
5782 pub const DESCRIPTOR_SET_LAYOUT_CREATE_INFO: Self = Self(32i32);
5783 pub const DESCRIPTOR_POOL_CREATE_INFO: Self = Self(33i32);
5784 pub const DESCRIPTOR_SET_ALLOCATE_INFO: Self = Self(34i32);
5785 pub const WRITE_DESCRIPTOR_SET: Self = Self(35i32);
5786 pub const COPY_DESCRIPTOR_SET: Self = Self(36i32);
5787 pub const FRAMEBUFFER_CREATE_INFO: Self = Self(37i32);
5788 pub const RENDER_PASS_CREATE_INFO: Self = Self(38i32);
5789 pub const COMMAND_POOL_CREATE_INFO: Self = Self(39i32);
5790 pub const COMMAND_BUFFER_ALLOCATE_INFO: Self = Self(40i32);
5791 pub const COMMAND_BUFFER_INHERITANCE_INFO: Self = Self(41i32);
5792 pub const COMMAND_BUFFER_BEGIN_INFO: Self = Self(42i32);
5793 pub const RENDER_PASS_BEGIN_INFO: Self = Self(43i32);
5794 pub const BUFFER_MEMORY_BARRIER: Self = Self(44i32);
5795 pub const IMAGE_MEMORY_BARRIER: Self = Self(45i32);
5796 pub const MEMORY_BARRIER: Self = Self(46i32);
5797 pub const LOADER_INSTANCE_CREATE_INFO: Self = Self(47i32);
5799 pub const LOADER_DEVICE_CREATE_INFO: Self = Self(48i32);
5801 pub const BIND_BUFFER_MEMORY_INFO: Self = Self(1000157000i32);
5802 pub const BIND_IMAGE_MEMORY_INFO: Self = Self(1000157001i32);
5803 pub const MEMORY_DEDICATED_REQUIREMENTS: Self = Self(1000127000i32);
5804 pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = Self(1000127001i32);
5805 pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = Self(1000060000i32);
5806 pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = Self(1000060004i32);
5807 pub const DEVICE_GROUP_SUBMIT_INFO: Self = Self(1000060005i32);
5808 pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = Self(1000060006i32);
5809 pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = Self(1000060013i32);
5810 pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = Self(1000060014i32);
5811 pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = Self(1000070000i32);
5812 pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = Self(1000070001i32);
5813 pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146000i32);
5814 pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146001i32);
5815 pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146002i32);
5816 pub const MEMORY_REQUIREMENTS_2: Self = Self(1000146003i32);
5817 pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = Self(1000146004i32);
5818 pub const PHYSICAL_DEVICE_FEATURES_2: Self = Self(1000059000i32);
5819 pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = Self(1000059001i32);
5820 pub const FORMAT_PROPERTIES_2: Self = Self(1000059002i32);
5821 pub const IMAGE_FORMAT_PROPERTIES_2: Self = Self(1000059003i32);
5822 pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = Self(1000059004i32);
5823 pub const QUEUE_FAMILY_PROPERTIES_2: Self = Self(1000059005i32);
5824 pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = Self(1000059006i32);
5825 pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = Self(1000059007i32);
5826 pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = Self(1000059008i32);
5827 pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = Self(1000117002i32);
5828 pub const PROTECTED_SUBMIT_INFO: Self = Self(1000145000i32);
5829 pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = Self(1000145001i32);
5830 pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = Self(1000145002i32);
5831 pub const DEVICE_QUEUE_INFO_2: Self = Self(1000145003i32);
5832 pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = Self(1000071000i32);
5833 pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = Self(1000071001i32);
5834 pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = Self(1000071002i32);
5835 pub const EXTERNAL_BUFFER_PROPERTIES: Self = Self(1000071003i32);
5836 pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = Self(1000071004i32);
5837 pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = Self(1000072000i32);
5838 pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = Self(1000072001i32);
5839 pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = Self(1000072002i32);
5840 pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = Self(1000112000i32);
5841 pub const EXTERNAL_FENCE_PROPERTIES: Self = Self(1000112001i32);
5842 pub const EXPORT_FENCE_CREATE_INFO: Self = Self(1000113000i32);
5843 pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = Self(1000077000i32);
5844 pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = Self(1000076000i32);
5845 pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = Self(1000076001i32);
5846 pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = Self(1000094000i32);
5847 pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = Self(1000083000i32);
5848 pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = Self(1000120000i32);
5849 pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self = Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
5850 pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = Self(1000085000i32);
5851 pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = Self(1000168000i32);
5852 pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = Self(1000168001i32);
5853 pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = Self(1000156000i32);
5854 pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = Self(1000156001i32);
5855 pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = Self(1000156002i32);
5856 pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = Self(1000156003i32);
5857 pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = Self(
5858 1000156004i32,
5859 );
5860 pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = Self(
5861 1000156005i32,
5862 );
5863 pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = Self(1000060003i32);
5864 pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = Self(1000117000i32);
5865 pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = Self(
5866 1000117001i32,
5867 );
5868 pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = Self(
5869 1000117003i32,
5870 );
5871 pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = Self(1000053000i32);
5872 pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = Self(1000053001i32);
5873 pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = Self(1000053002i32);
5874 pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: Self = Self(
5875 1000063000i32,
5876 );
5877 pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
5878 pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES: Self = Self(1000196000i32);
5879 pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = Self(49i32);
5880 pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = Self(50i32);
5881 pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = Self(51i32);
5882 pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = Self(52i32);
5883 pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = Self(1000147000i32);
5884 pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: Self = Self(1000211000i32);
5885 pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: Self = Self(1000261000i32);
5886 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: Self = Self(1000207000i32);
5887 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: Self = Self(1000207001i32);
5888 pub const SEMAPHORE_TYPE_CREATE_INFO: Self = Self(1000207002i32);
5889 pub const TIMELINE_SEMAPHORE_SUBMIT_INFO: Self = Self(1000207003i32);
5890 pub const SEMAPHORE_WAIT_INFO: Self = Self(1000207004i32);
5891 pub const SEMAPHORE_SIGNAL_INFO: Self = Self(1000207005i32);
5892 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: Self = Self(1000257000i32);
5893 pub const BUFFER_DEVICE_ADDRESS_INFO: Self = Self(1000244001i32);
5894 pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: Self = Self(1000257002i32);
5895 pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: Self = Self(1000257003i32);
5896 pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: Self = Self(1000257004i32);
5897 pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: Self = Self(1000177000i32);
5898 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: Self = Self(1000180000i32);
5899 pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: Self = Self(1000082000i32);
5900 pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: Self = Self(1000197000i32);
5901 pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: Self = Self(
5902 1000161000i32,
5903 );
5904 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: Self = Self(1000161001i32);
5905 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: Self = Self(1000161002i32);
5906 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: Self = Self(
5907 1000161003i32,
5908 );
5909 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: Self = Self(
5910 1000161004i32,
5911 );
5912 pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: Self = Self(1000221000i32);
5913 pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: Self = Self(
5914 1000130000i32,
5915 );
5916 pub const SAMPLER_REDUCTION_MODE_CREATE_INFO: Self = Self(1000130001i32);
5917 pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: Self = Self(
5918 1000253000i32,
5919 );
5920 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: Self = Self(
5921 1000175000i32,
5922 );
5923 pub const ATTACHMENT_DESCRIPTION_2: Self = Self(1000109000i32);
5924 pub const ATTACHMENT_REFERENCE_2: Self = Self(1000109001i32);
5925 pub const SUBPASS_DESCRIPTION_2: Self = Self(1000109002i32);
5926 pub const SUBPASS_DEPENDENCY_2: Self = Self(1000109003i32);
5927 pub const RENDER_PASS_CREATE_INFO_2: Self = Self(1000109004i32);
5928 pub const SUBPASS_BEGIN_INFO: Self = Self(1000109005i32);
5929 pub const SUBPASS_END_INFO: Self = Self(1000109006i32);
5930 pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: Self = Self(
5931 1000199000i32,
5932 );
5933 pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: Self = Self(1000199001i32);
5934 pub const IMAGE_STENCIL_USAGE_CREATE_INFO: Self = Self(1000246000i32);
5935 pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: Self = Self(1000108000i32);
5936 pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: Self = Self(1000108001i32);
5937 pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: Self = Self(1000108002i32);
5938 pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO: Self = Self(1000108003i32);
5939 pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: Self = Self(
5940 1000241000i32,
5941 );
5942 pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT: Self = Self(1000241001i32);
5943 pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: Self = Self(1000241002i32);
5944 pub const PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: Self = Self(53i32);
5945 pub const PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: Self = Self(54i32);
5946 pub const PHYSICAL_DEVICE_TOOL_PROPERTIES: Self = Self(1000245000i32);
5947 pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: Self = Self(1000295000i32);
5948 pub const DEVICE_PRIVATE_DATA_CREATE_INFO: Self = Self(1000295001i32);
5949 pub const PRIVATE_DATA_SLOT_CREATE_INFO: Self = Self(1000295002i32);
5950 pub const MEMORY_BARRIER_2: Self = Self(1000314000i32);
5951 pub const BUFFER_MEMORY_BARRIER_2: Self = Self(1000314001i32);
5952 pub const IMAGE_MEMORY_BARRIER_2: Self = Self(1000314002i32);
5953 pub const DEPENDENCY_INFO: Self = Self(1000314003i32);
5954 pub const SUBMIT_INFO_2: Self = Self(1000314004i32);
5955 pub const SEMAPHORE_SUBMIT_INFO: Self = Self(1000314005i32);
5956 pub const COMMAND_BUFFER_SUBMIT_INFO: Self = Self(1000314006i32);
5957 pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: Self = Self(1000314007i32);
5958 pub const COPY_BUFFER_INFO_2: Self = Self(1000337000i32);
5959 pub const COPY_IMAGE_INFO_2: Self = Self(1000337001i32);
5960 pub const COPY_BUFFER_TO_IMAGE_INFO_2: Self = Self(1000337002i32);
5961 pub const COPY_IMAGE_TO_BUFFER_INFO_2: Self = Self(1000337003i32);
5962 pub const BUFFER_COPY_2: Self = Self(1000337006i32);
5963 pub const IMAGE_COPY_2: Self = Self(1000337007i32);
5964 pub const BUFFER_IMAGE_COPY_2: Self = Self(1000337009i32);
5965 pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: Self = Self(
5966 1000066000i32,
5967 );
5968 pub const FORMAT_PROPERTIES_3: Self = Self(1000360000i32);
5969 pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: Self = Self(1000413000i32);
5970 pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: Self = Self(1000413001i32);
5971 pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS: Self = Self(1000413002i32);
5972 pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS: Self = Self(1000413003i32);
5973 pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO: Self = Self(1000192000i32);
5974 pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: Self = Self(
5975 1000215000i32,
5976 );
5977 pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: Self = Self(
5978 1000276000i32,
5979 );
5980 pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: Self = Self(
5981 1000297000i32,
5982 );
5983 pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: Self = Self(
5984 1000325000i32,
5985 );
5986 pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: Self = Self(1000335000i32);
5987 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: Self = Self(
5988 1000225000i32,
5989 );
5990 pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: Self = Self(
5991 1000225001i32,
5992 );
5993 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: Self = Self(1000225002i32);
5994 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: Self = Self(1000138000i32);
5995 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: Self = Self(
5996 1000138001i32,
5997 );
5998 pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: Self = Self(1000138002i32);
5999 pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: Self = Self(
6000 1000138003i32,
6001 );
6002 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: Self = Self(
6003 1000280000i32,
6004 );
6005 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: Self = Self(
6006 1000280001i32,
6007 );
6008 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: Self = Self(
6009 1000281001i32,
6010 );
6011 pub const BLIT_IMAGE_INFO_2: Self = Self(1000337004i32);
6012 pub const RESOLVE_IMAGE_INFO_2: Self = Self(1000337005i32);
6013 pub const IMAGE_BLIT_2: Self = Self(1000337008i32);
6014 pub const IMAGE_RESOLVE_2: Self = Self(1000337010i32);
6015 pub const RENDERING_INFO: Self = Self(1000044000i32);
6016 pub const RENDERING_ATTACHMENT_INFO: Self = Self(1000044001i32);
6017 pub const PIPELINE_RENDERING_CREATE_INFO: Self = Self(1000044002i32);
6018 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: Self = Self(1000044003i32);
6019 pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: Self = Self(1000044004i32);
6020 pub const PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: Self = Self(55i32);
6021 pub const PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: Self = Self(56i32);
6022 pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: Self = Self(1000174000i32);
6023 pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: Self = Self(1000388000i32);
6024 pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: Self = Self(1000388001i32);
6025 pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: Self = Self(1000265000i32);
6026 pub const MEMORY_MAP_INFO: Self = Self(1000271000i32);
6027 pub const MEMORY_UNMAP_INFO: Self = Self(1000271001i32);
6028 pub const PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: Self = Self(1000470000i32);
6029 pub const PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: Self = Self(1000470001i32);
6030 pub const DEVICE_IMAGE_SUBRESOURCE_INFO: Self = Self(1000470004i32);
6031 pub const SUBRESOURCE_LAYOUT_2: Self = Self(1000338002i32);
6032 pub const IMAGE_SUBRESOURCE_2: Self = Self(1000338003i32);
6033 pub const BUFFER_USAGE_FLAGS_2_CREATE_INFO: Self = Self(1000470006i32);
6034 pub const PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: Self = Self(1000545000i32);
6035 pub const PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: Self = Self(1000545001i32);
6036 pub const BIND_MEMORY_STATUS: Self = Self(1000545002i32);
6037 pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: Self = Self(1000270000i32);
6038 pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: Self = Self(1000270001i32);
6039 pub const MEMORY_TO_IMAGE_COPY: Self = Self(1000270002i32);
6040 pub const IMAGE_TO_MEMORY_COPY: Self = Self(1000270003i32);
6041 pub const COPY_IMAGE_TO_MEMORY_INFO: Self = Self(1000270004i32);
6042 pub const COPY_MEMORY_TO_IMAGE_INFO: Self = Self(1000270005i32);
6043 pub const HOST_IMAGE_LAYOUT_TRANSITION_INFO: Self = Self(1000270006i32);
6044 pub const COPY_IMAGE_TO_IMAGE_INFO: Self = Self(1000270007i32);
6045 pub const SUBRESOURCE_HOST_MEMCPY_SIZE: Self = Self(1000270008i32);
6046 pub const HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: Self = Self(1000270009i32);
6047 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: Self = Self(
6048 1000416000i32,
6049 );
6050 pub const PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: Self = Self(
6051 1000528000i32,
6052 );
6053 pub const PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: Self = Self(1000544000i32);
6054 pub const PIPELINE_CREATE_FLAGS_2_CREATE_INFO: Self = Self(1000470005i32);
6055 pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: Self = Self(1000080000i32);
6056 pub const BIND_DESCRIPTOR_SETS_INFO: Self = Self(1000545003i32);
6057 pub const PUSH_CONSTANTS_INFO: Self = Self(1000545004i32);
6058 pub const PUSH_DESCRIPTOR_SET_INFO: Self = Self(1000545005i32);
6059 pub const PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: Self = Self(1000545006i32);
6060 pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: Self = Self(
6061 1000466000i32,
6062 );
6063 pub const PIPELINE_ROBUSTNESS_CREATE_INFO: Self = Self(1000068000i32);
6064 pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: Self = Self(1000068001i32);
6065 pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: Self = Self(1000068002i32);
6066 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: Self = Self(1000259000i32);
6067 pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: Self = Self(1000259001i32);
6068 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: Self = Self(1000259002i32);
6069 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: Self = Self(
6070 1000525000i32,
6071 );
6072 pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: Self = Self(
6073 1000190001i32,
6074 );
6075 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: Self = Self(
6076 1000190002i32,
6077 );
6078 pub const RENDERING_AREA_INFO: Self = Self(1000470003i32);
6079 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: Self = Self(
6080 1000232000i32,
6081 );
6082 pub const RENDERING_ATTACHMENT_LOCATION_INFO: Self = Self(1000232001i32);
6083 pub const RENDERING_INPUT_ATTACHMENT_INDEX_INFO: Self = Self(1000232002i32);
6084 pub const PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES: Self = Self(1000298000i32);
6085 pub const PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES: Self = Self(1000298001i32);
6086 pub const DEVICE_OBJECT_RESERVATION_CREATE_INFO: Self = Self(1000298002i32);
6087 pub const COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO: Self = Self(1000298003i32);
6088 pub const COMMAND_POOL_MEMORY_CONSUMPTION: Self = Self(1000298004i32);
6089 pub const PIPELINE_POOL_SIZE: Self = Self(1000298005i32);
6090 pub const FAULT_DATA: Self = Self(1000298007i32);
6091 pub const FAULT_CALLBACK_INFO: Self = Self(1000298008i32);
6092 pub const PIPELINE_OFFLINE_CREATE_INFO: Self = Self(1000298010i32);
6093 pub const SWAPCHAIN_CREATE_INFO: Self = Self(1000001000i32);
6094 pub const PRESENT_INFO: Self = Self(1000001001i32);
6095 pub const DEVICE_GROUP_PRESENT_CAPABILITIES: Self = Self(1000060007i32);
6096 pub const IMAGE_SWAPCHAIN_CREATE_INFO: Self = Self(1000060008i32);
6097 pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO: Self = Self(1000060009i32);
6098 pub const ACQUIRE_NEXT_IMAGE_INFO: Self = Self(1000060010i32);
6099 pub const DEVICE_GROUP_PRESENT_INFO: Self = Self(1000060011i32);
6100 pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO: Self = Self(1000060012i32);
6101 pub const DISPLAY_MODE_CREATE_INFO: Self = Self(1000002000i32);
6102 pub const DISPLAY_SURFACE_CREATE_INFO: Self = Self(1000002001i32);
6103 pub const DISPLAY_PRESENT_INFO: Self = Self(1000003000i32);
6104 pub const XLIB_SURFACE_CREATE_INFO: Self = Self(1000004000i32);
6105 pub const XCB_SURFACE_CREATE_INFO: Self = Self(1000005000i32);
6106 pub const WAYLAND_SURFACE_CREATE_INFO: Self = Self(1000006000i32);
6107 pub const ANDROID_SURFACE_CREATE_INFO: Self = Self(1000008000i32);
6108 pub const WIN32_SURFACE_CREATE_INFO: Self = Self(1000009000i32);
6109 pub const DEBUG_REPORT_CALLBACK_CREATE_INFO: Self = Self(1000011000i32);
6110 pub const DEBUG_REPORT_CREATE_INFO: Self = Self::DEBUG_REPORT_CALLBACK_CREATE_INFO;
6111 pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER: Self = Self(
6112 1000018000i32,
6113 );
6114 pub const DEBUG_MARKER_OBJECT_NAME_INFO: Self = Self(1000022000i32);
6115 pub const DEBUG_MARKER_OBJECT_TAG_INFO: Self = Self(1000022001i32);
6116 pub const DEBUG_MARKER_MARKER_INFO: Self = Self(1000022002i32);
6117 pub const VIDEO_PROFILE_INFO: Self = Self(1000023000i32);
6118 pub const VIDEO_CAPABILITIES: Self = Self(1000023001i32);
6119 pub const VIDEO_PICTURE_RESOURCE_INFO: Self = Self(1000023002i32);
6120 pub const VIDEO_SESSION_MEMORY_REQUIREMENTS: Self = Self(1000023003i32);
6121 pub const BIND_VIDEO_SESSION_MEMORY_INFO: Self = Self(1000023004i32);
6122 pub const VIDEO_SESSION_CREATE_INFO: Self = Self(1000023005i32);
6123 pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO: Self = Self(1000023006i32);
6124 pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO: Self = Self(1000023007i32);
6125 pub const VIDEO_BEGIN_CODING_INFO: Self = Self(1000023008i32);
6126 pub const VIDEO_END_CODING_INFO: Self = Self(1000023009i32);
6127 pub const VIDEO_CODING_CONTROL_INFO: Self = Self(1000023010i32);
6128 pub const VIDEO_REFERENCE_SLOT_INFO: Self = Self(1000023011i32);
6129 pub const QUEUE_FAMILY_VIDEO_PROPERTIES: Self = Self(1000023012i32);
6130 pub const VIDEO_PROFILE_LIST_INFO: Self = Self(1000023013i32);
6131 pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO: Self = Self(1000023014i32);
6132 pub const VIDEO_FORMAT_PROPERTIES: Self = Self(1000023015i32);
6133 pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES: Self = Self(1000023016i32);
6134 pub const VIDEO_DECODE_INFO: Self = Self(1000024000i32);
6135 pub const VIDEO_DECODE_CAPABILITIES: Self = Self(1000024001i32);
6136 pub const VIDEO_DECODE_USAGE_INFO: Self = Self(1000024002i32);
6137 pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO: Self = Self(1000026000i32);
6138 pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO: Self = Self(1000026001i32);
6139 pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO: Self = Self(1000026002i32);
6140 pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES: Self = Self(1000028000i32);
6141 pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES: Self = Self(1000028001i32);
6142 pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO: Self = Self(
6143 1000028002i32,
6144 );
6145 pub const CU_MODULE_CREATE_INFO: Self = Self(1000029000i32);
6146 pub const CU_FUNCTION_CREATE_INFO: Self = Self(1000029001i32);
6147 pub const CU_LAUNCH_INFO: Self = Self(1000029002i32);
6148 pub const CU_MODULE_TEXTURING_MODE_CREATE_INFO: Self = Self(1000029004i32);
6149 pub const IMAGE_VIEW_HANDLE_INFO: Self = Self(1000030000i32);
6150 pub const IMAGE_VIEW_ADDRESS_PROPERTIES: Self = Self(1000030001i32);
6151 pub const VIDEO_ENCODE_H264_CAPABILITIES: Self = Self(1000038000i32);
6152 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
6153 1000038001i32,
6154 );
6155 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO: Self = Self(1000038002i32);
6156 pub const VIDEO_ENCODE_H264_PICTURE_INFO: Self = Self(1000038003i32);
6157 pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO: Self = Self(1000038004i32);
6158 pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO: Self = Self(1000038005i32);
6159 pub const VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO: Self = Self(1000038006i32);
6160 pub const VIDEO_ENCODE_H264_PROFILE_INFO: Self = Self(1000038007i32);
6161 pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO: Self = Self(1000038008i32);
6162 pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO: Self = Self(1000038009i32);
6163 pub const VIDEO_ENCODE_H264_SESSION_CREATE_INFO: Self = Self(1000038010i32);
6164 pub const VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES: Self = Self(1000038011i32);
6165 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO: Self = Self(1000038012i32);
6166 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO: Self = Self(
6167 1000038013i32,
6168 );
6169 pub const VIDEO_ENCODE_H265_CAPABILITIES: Self = Self(1000039000i32);
6170 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
6171 1000039001i32,
6172 );
6173 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO: Self = Self(1000039002i32);
6174 pub const VIDEO_ENCODE_H265_PICTURE_INFO: Self = Self(1000039003i32);
6175 pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO: Self = Self(1000039004i32);
6176 pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO: Self = Self(1000039005i32);
6177 pub const VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO: Self = Self(1000039006i32);
6178 pub const VIDEO_ENCODE_H265_PROFILE_INFO: Self = Self(1000039007i32);
6179 pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO: Self = Self(1000039009i32);
6180 pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO: Self = Self(1000039010i32);
6181 pub const VIDEO_ENCODE_H265_SESSION_CREATE_INFO: Self = Self(1000039011i32);
6182 pub const VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES: Self = Self(1000039012i32);
6183 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO: Self = Self(1000039013i32);
6184 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO: Self = Self(
6185 1000039014i32,
6186 );
6187 pub const VIDEO_DECODE_H264_CAPABILITIES: Self = Self(1000040000i32);
6188 pub const VIDEO_DECODE_H264_PICTURE_INFO: Self = Self(1000040001i32);
6189 pub const VIDEO_DECODE_H264_PROFILE_INFO: Self = Self(1000040003i32);
6190 pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
6191 1000040004i32,
6192 );
6193 pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO: Self = Self(1000040005i32);
6194 pub const VIDEO_DECODE_H264_DPB_SLOT_INFO: Self = Self(1000040006i32);
6195 pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES: Self = Self(1000041000i32);
6196 pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO: Self = Self(1000049000i32);
6197 pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES: Self = Self(1000050000i32);
6198 pub const IMPORT_MEMORY_WIN32_HANDLE_INFO: Self = Self(1000057000i32);
6199 pub const EXPORT_MEMORY_WIN32_HANDLE_INFO: Self = Self(1000057001i32);
6200 pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO: Self = Self(1000058000i32);
6201 pub const VALIDATION_FLAGS: Self = Self(1000061000i32);
6202 pub const VI_SURFACE_CREATE_INFO: Self = Self(1000062000i32);
6203 pub const IMAGE_VIEW_ASTC_DECODE_MODE: Self = Self(1000067000i32);
6204 pub const PHYSICAL_DEVICE_ASTC_DECODE_FEATURES: Self = Self(1000067001i32);
6205 pub const MEMORY_WIN32_HANDLE_PROPERTIES: Self = Self(1000073002i32);
6206 pub const MEMORY_GET_WIN32_HANDLE_INFO: Self = Self(1000073003i32);
6207 pub const IMPORT_MEMORY_FD_INFO: Self = Self(1000074000i32);
6208 pub const MEMORY_FD_PROPERTIES: Self = Self(1000074001i32);
6209 pub const MEMORY_GET_FD_INFO: Self = Self(1000074002i32);
6210 pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO: Self = Self(1000078000i32);
6211 pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO: Self = Self(1000078001i32);
6212 pub const D3D12_FENCE_SUBMIT_INFO: Self = Self(1000078002i32);
6213 pub const SEMAPHORE_GET_WIN32_HANDLE_INFO: Self = Self(1000078003i32);
6214 pub const IMPORT_SEMAPHORE_FD_INFO: Self = Self(1000079000i32);
6215 pub const SEMAPHORE_GET_FD_INFO: Self = Self(1000079001i32);
6216 pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO: Self = Self(
6217 1000081000i32,
6218 );
6219 pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES: Self = Self(1000081001i32);
6220 pub const CONDITIONAL_RENDERING_BEGIN_INFO: Self = Self(1000081002i32);
6221 pub const PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES: Self = Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
6222 pub const PRESENT_REGIONS: Self = Self(1000084000i32);
6223 pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO: Self = Self(1000087000i32);
6224 pub const SURFACE_CAPABILITIES_2: Self = Self(1000090000i32);
6225 pub const SURFACE_CAPABILITIES2: Self = Self::SURFACE_CAPABILITIES_2;
6226 pub const DISPLAY_POWER_INFO: Self = Self(1000091000i32);
6227 pub const DEVICE_EVENT_INFO: Self = Self(1000091001i32);
6228 pub const DISPLAY_EVENT_INFO: Self = Self(1000091002i32);
6229 pub const SWAPCHAIN_COUNTER_CREATE_INFO: Self = Self(1000091003i32);
6230 pub const PRESENT_TIMES_INFO: Self = Self(1000092000i32);
6231 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES: Self = Self(
6232 1000097000i32,
6233 );
6234 pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO: Self = Self(1000044009i32);
6235 pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO: Self = Self(1000098000i32);
6236 pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES: Self = Self(1000099000i32);
6237 pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO: Self = Self(1000099001i32);
6238 pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES: Self = Self(
6239 1000101000i32,
6240 );
6241 pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO: Self = Self(
6242 1000101001i32,
6243 );
6244 pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES: Self = Self(1000102000i32);
6245 pub const PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO: Self = Self(
6246 1000102001i32,
6247 );
6248 pub const HDR_METADATA: Self = Self(1000105000i32);
6249 pub const PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES: Self = Self(
6250 1000110000i32,
6251 );
6252 pub const SHARED_PRESENT_SURFACE_CAPABILITIES: Self = Self(1000111000i32);
6253 pub const IMPORT_FENCE_WIN32_HANDLE_INFO: Self = Self(1000114000i32);
6254 pub const EXPORT_FENCE_WIN32_HANDLE_INFO: Self = Self(1000114001i32);
6255 pub const FENCE_GET_WIN32_HANDLE_INFO: Self = Self(1000114002i32);
6256 pub const IMPORT_FENCE_FD_INFO: Self = Self(1000115000i32);
6257 pub const FENCE_GET_FD_INFO: Self = Self(1000115001i32);
6258 pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES: Self = Self(1000116000i32);
6259 pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES: Self = Self(1000116001i32);
6260 pub const QUERY_POOL_PERFORMANCE_CREATE_INFO: Self = Self(1000116002i32);
6261 pub const PERFORMANCE_QUERY_SUBMIT_INFO: Self = Self(1000116003i32);
6262 pub const ACQUIRE_PROFILING_LOCK_INFO: Self = Self(1000116004i32);
6263 pub const PERFORMANCE_COUNTER: Self = Self(1000116005i32);
6264 pub const PERFORMANCE_COUNTER_DESCRIPTION: Self = Self(1000116006i32);
6265 pub const PERFORMANCE_QUERY_RESERVATION_INFO: Self = Self(1000116007i32);
6266 pub const PHYSICAL_DEVICE_SURFACE_INFO_2: Self = Self(1000119000i32);
6267 pub const SURFACE_FORMAT_2: Self = Self(1000119002i32);
6268 pub const DISPLAY_PROPERTIES_2: Self = Self(1000121000i32);
6269 pub const DISPLAY_PLANE_PROPERTIES_2: Self = Self(1000121001i32);
6270 pub const DISPLAY_MODE_PROPERTIES_2: Self = Self(1000121002i32);
6271 pub const DISPLAY_PLANE_INFO_2: Self = Self(1000121003i32);
6272 pub const DISPLAY_PLANE_CAPABILITIES_2: Self = Self(1000121004i32);
6273 pub const IOS_SURFACE_CREATE_INFO: Self = Self(1000122000i32);
6274 pub const MACOS_SURFACE_CREATE_INFO: Self = Self(1000123000i32);
6275 pub const DEBUG_UTILS_OBJECT_NAME_INFO: Self = Self(1000128000i32);
6276 pub const DEBUG_UTILS_OBJECT_TAG_INFO: Self = Self(1000128001i32);
6277 pub const DEBUG_UTILS_LABEL: Self = Self(1000128002i32);
6278 pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA: Self = Self(1000128003i32);
6279 pub const DEBUG_UTILS_MESSENGER_CREATE_INFO: Self = Self(1000128004i32);
6280 pub const ANDROID_HARDWARE_BUFFER_USAGE: Self = Self(1000129000i32);
6281 pub const ANDROID_HARDWARE_BUFFER_PROPERTIES: Self = Self(1000129001i32);
6282 pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES: Self = Self(1000129002i32);
6283 pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO: Self = Self(1000129003i32);
6284 pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO: Self = Self(1000129004i32);
6285 pub const EXTERNAL_FORMAT: Self = Self(1000129005i32);
6286 pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2: Self = Self(1000129006i32);
6287 pub const PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES: Self = Self(1000134000i32);
6288 pub const PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES: Self = Self(1000134001i32);
6289 pub const EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE: Self = Self(1000134002i32);
6290 pub const EXECUTION_GRAPH_PIPELINE_CREATE_INFO: Self = Self(1000134003i32);
6291 pub const PIPELINE_SHADER_STAGE_NODE_CREATE_INFO: Self = Self(1000134004i32);
6292 pub const TEXEL_BUFFER_DESCRIPTOR_INFO: Self = Self(1000135000i32);
6293 pub const IMAGE_DESCRIPTOR_INFO: Self = Self(1000135001i32);
6294 pub const RESOURCE_DESCRIPTOR_INFO: Self = Self(1000135002i32);
6295 pub const BIND_HEAP_INFO: Self = Self(1000135003i32);
6296 pub const PUSH_DATA_INFO: Self = Self(1000135004i32);
6297 pub const DESCRIPTOR_SET_AND_BINDING_MAPPING: Self = Self(1000135005i32);
6298 pub const SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO: Self = Self(1000135006i32);
6299 pub const OPAQUE_CAPTURE_DATA_CREATE_INFO: Self = Self(1000135007i32);
6300 pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES: Self = Self(1000135008i32);
6301 pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES: Self = Self(1000135009i32);
6302 pub const COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO: Self = Self(
6303 1000135010i32,
6304 );
6305 pub const SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO: Self = Self(1000135011i32);
6306 pub const INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN: Self = Self(1000135012i32);
6307 pub const SUBSAMPLED_IMAGE_FORMAT_PROPERTIES: Self = Self(1000135013i32);
6308 pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES: Self = Self(
6309 1000135014i32,
6310 );
6311 pub const ATTACHMENT_SAMPLE_COUNT_INFO: Self = Self(1000044008i32);
6312 pub const PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES: Self = Self(1000141000i32);
6313 pub const SAMPLE_LOCATIONS_INFO: Self = Self(1000143000i32);
6314 pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO: Self = Self(1000143001i32);
6315 pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO: Self = Self(1000143002i32);
6316 pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES: Self = Self(1000143003i32);
6317 pub const MULTISAMPLE_PROPERTIES: Self = Self(1000143004i32);
6318 pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES: Self = Self(
6319 1000148000i32,
6320 );
6321 pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES: Self = Self(
6322 1000148001i32,
6323 );
6324 pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO: Self = Self(
6325 1000148002i32,
6326 );
6327 pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO: Self = Self(1000149000i32);
6328 pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE: Self = Self(1000150007i32);
6329 pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO: Self = Self(1000150000i32);
6330 pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO: Self = Self(1000150002i32);
6331 pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA: Self = Self(1000150003i32);
6332 pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA: Self = Self(1000150004i32);
6333 pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA: Self = Self(1000150005i32);
6334 pub const ACCELERATION_STRUCTURE_GEOMETRY: Self = Self(1000150006i32);
6335 pub const ACCELERATION_STRUCTURE_VERSION_INFO: Self = Self(1000150009i32);
6336 pub const COPY_ACCELERATION_STRUCTURE_INFO: Self = Self(1000150010i32);
6337 pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO: Self = Self(1000150011i32);
6338 pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO: Self = Self(1000150012i32);
6339 pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES: Self = Self(
6340 1000150013i32,
6341 );
6342 pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES: Self = Self(
6343 1000150014i32,
6344 );
6345 pub const ACCELERATION_STRUCTURE_CREATE_INFO: Self = Self(1000150017i32);
6346 pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO: Self = Self(1000150020i32);
6347 pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES: Self = Self(1000347000i32);
6348 pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES: Self = Self(
6349 1000347001i32,
6350 );
6351 pub const RAY_TRACING_PIPELINE_CREATE_INFO: Self = Self(1000150015i32);
6352 pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO: Self = Self(1000150016i32);
6353 pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO: Self = Self(1000150018i32);
6354 pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES: Self = Self(1000348013i32);
6355 pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO: Self = Self(1000152000i32);
6356 pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES: Self = Self(1000154000i32);
6357 pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES: Self = Self(1000154001i32);
6358 pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST: Self = Self(1000158000i32);
6359 pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO: Self = Self(1000158002i32);
6360 pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO: Self = Self(1000158003i32);
6361 pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO: Self = Self(1000158004i32);
6362 pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES: Self = Self(1000158005i32);
6363 pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2: Self = Self(1000158006i32);
6364 pub const VALIDATION_CACHE_CREATE_INFO: Self = Self(1000160000i32);
6365 pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO: Self = Self(1000160001i32);
6366 pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES: Self = Self(1000163000i32);
6367 pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES: Self = Self(1000163001i32);
6368 pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO: Self = Self(
6369 1000164000i32,
6370 );
6371 pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES: Self = Self(1000164001i32);
6372 pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES: Self = Self(1000164002i32);
6373 pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO: Self = Self(
6374 1000164005i32,
6375 );
6376 pub const GEOMETRY: Self = Self(1000165003i32);
6377 pub const GEOMETRY_TRIANGLES: Self = Self(1000165004i32);
6378 pub const GEOMETRY_AABB: Self = Self(1000165005i32);
6379 pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO: Self = Self(1000165006i32);
6380 pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO: Self = Self(
6381 1000165008i32,
6382 );
6383 pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES: Self = Self(1000165009i32);
6384 pub const ACCELERATION_STRUCTURE_INFO: Self = Self(1000165012i32);
6385 pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES: Self = Self(
6386 1000166000i32,
6387 );
6388 pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO: Self = Self(
6389 1000166001i32,
6390 );
6391 pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO: Self = Self(1000170000i32);
6392 pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES: Self = Self(
6393 1000170001i32,
6394 );
6395 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES: Self = Self(
6396 1000172000i32,
6397 );
6398 pub const IMPORT_MEMORY_HOST_POINTER_INFO: Self = Self(1000178000i32);
6399 pub const MEMORY_HOST_POINTER_PROPERTIES: Self = Self(1000178001i32);
6400 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES: Self = Self(
6401 1000178002i32,
6402 );
6403 pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES: Self = Self(1000181000i32);
6404 pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO: Self = Self(1000183000i32);
6405 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES: Self = Self(1000185000i32);
6406 pub const VIDEO_DECODE_H265_CAPABILITIES: Self = Self(1000187000i32);
6407 pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
6408 1000187001i32,
6409 );
6410 pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO: Self = Self(1000187002i32);
6411 pub const VIDEO_DECODE_H265_PROFILE_INFO: Self = Self(1000187003i32);
6412 pub const VIDEO_DECODE_H265_PICTURE_INFO: Self = Self(1000187004i32);
6413 pub const VIDEO_DECODE_H265_DPB_SLOT_INFO: Self = Self(1000187005i32);
6414 pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO: Self = Self(1000189000i32);
6415 pub const PRESENT_FRAME_TOKEN: Self = Self(1000191000i32);
6416 pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES: Self = Self(1000202000i32);
6417 pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES: Self = Self(1000202001i32);
6418 pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES: Self = Self(
6419 1000204000i32,
6420 );
6421 pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO: Self = Self(
6422 1000205000i32,
6423 );
6424 pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES: Self = Self(1000205002i32);
6425 pub const CHECKPOINT_DATA: Self = Self(1000206000i32);
6426 pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES: Self = Self(1000206001i32);
6427 pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2: Self = Self(1000314008i32);
6428 pub const CHECKPOINT_DATA_2: Self = Self(1000314009i32);
6429 pub const PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES: Self = Self(1000208000i32);
6430 pub const SWAPCHAIN_TIMING_PROPERTIES: Self = Self(1000208001i32);
6431 pub const SWAPCHAIN_TIME_DOMAIN_PROPERTIES: Self = Self(1000208002i32);
6432 pub const PRESENT_TIMINGS_INFO: Self = Self(1000208003i32);
6433 pub const PRESENT_TIMING_INFO: Self = Self(1000208004i32);
6434 pub const PAST_PRESENTATION_TIMING_INFO: Self = Self(1000208005i32);
6435 pub const PAST_PRESENTATION_TIMING_PROPERTIES: Self = Self(1000208006i32);
6436 pub const PAST_PRESENTATION_TIMING: Self = Self(1000208007i32);
6437 pub const PRESENT_TIMING_SURFACE_CAPABILITIES: Self = Self(1000208008i32);
6438 pub const SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO: Self = Self(1000208009i32);
6439 pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES: Self = Self(
6440 1000209000i32,
6441 );
6442 pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO: Self = Self(1000210000i32);
6443 pub const INITIALIZE_PERFORMANCE_API_INFO: Self = Self(1000210001i32);
6444 pub const PERFORMANCE_MARKER_INFO: Self = Self(1000210002i32);
6445 pub const PERFORMANCE_STREAM_MARKER_INFO: Self = Self(1000210003i32);
6446 pub const PERFORMANCE_OVERRIDE_INFO: Self = Self(1000210004i32);
6447 pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO: Self = Self(1000210005i32);
6448 pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES: Self = Self(1000212000i32);
6449 pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES: Self = Self(1000213000i32);
6450 pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO: Self = Self(1000213001i32);
6451 pub const IMAGEPIPE_SURFACE_CREATE_INFO: Self = Self(1000214000i32);
6452 pub const METAL_SURFACE_CREATE_INFO: Self = Self(1000217000i32);
6453 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES: Self = Self(1000218000i32);
6454 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES: Self = Self(
6455 1000218001i32,
6456 );
6457 pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO: Self = Self(1000218002i32);
6458 pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO: Self = Self(1000044007i32);
6459 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO: Self = Self(1000226000i32);
6460 pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO: Self = Self(
6461 1000226001i32,
6462 );
6463 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES: Self = Self(
6464 1000226002i32,
6465 );
6466 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES: Self = Self(1000226003i32);
6467 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE: Self = Self(1000226004i32);
6468 pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO: Self = Self(
6469 1000044006i32,
6470 );
6471 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2: Self = Self(1000227000i32);
6472 pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES: Self = Self(1000229000i32);
6473 pub const PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES: Self = Self(1000231000i32);
6474 pub const PHYSICAL_DEVICE_SHADER_ABORT_FEATURES: Self = Self(1000233000i32);
6475 pub const DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO: Self = Self(1000233001i32);
6476 pub const PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES: Self = Self(1000233002i32);
6477 pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES: Self = Self(
6478 1000234000i32,
6479 );
6480 pub const PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES: Self = Self(1000235000i32);
6481 pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES: Self = Self(1000237000i32);
6482 pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES: Self = Self(1000238000i32);
6483 pub const MEMORY_PRIORITY_ALLOCATE_INFO: Self = Self(1000238001i32);
6484 pub const SURFACE_PROTECTED_CAPABILITIES: Self = Self(1000239000i32);
6485 pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES: Self = Self(
6486 1000240000i32,
6487 );
6488 pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES: Self = Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
6489 pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO: Self = Self(1000244002i32);
6490 pub const VALIDATION_FEATURES: Self = Self(1000247000i32);
6491 pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES: Self = Self(1000248000i32);
6492 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES: Self = Self(1000249000i32);
6493 pub const COOPERATIVE_MATRIX_PROPERTIES: Self = Self(1000249001i32);
6494 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES: Self = Self(1000249002i32);
6495 pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES: Self = Self(
6496 1000250000i32,
6497 );
6498 pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO: Self = Self(1000250001i32);
6499 pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION: Self = Self(1000250002i32);
6500 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES: Self = Self(
6501 1000251000i32,
6502 );
6503 pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES: Self = Self(1000252000i32);
6504 pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES: Self = Self(1000254000i32);
6505 pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO: Self = Self(
6506 1000254001i32,
6507 );
6508 pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES: Self = Self(1000254002i32);
6509 pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO: Self = Self(1000255000i32);
6510 pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE: Self = Self(1000255002i32);
6511 pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO: Self = Self(1000255001i32);
6512 pub const HEADLESS_SURFACE_CREATE_INFO: Self = Self(1000256000i32);
6513 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES: Self = Self(1000260000i32);
6514 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES: Self = Self(
6516 1000267000i32,
6517 );
6518 pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES: Self = Self(
6519 1000269000i32,
6520 );
6521 pub const PIPELINE_INFO: Self = Self(1000269001i32);
6522 pub const PIPELINE_EXECUTABLE_PROPERTIES: Self = Self(1000269002i32);
6523 pub const PIPELINE_EXECUTABLE_INFO: Self = Self(1000269003i32);
6524 pub const PIPELINE_EXECUTABLE_STATISTIC: Self = Self(1000269004i32);
6525 pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION: Self = Self(1000269005i32);
6526 pub const PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES: Self = Self(1000272000i32);
6527 pub const PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES: Self = Self(1000272001i32);
6528 pub const MEMORY_MAP_PLACED_INFO: Self = Self(1000272002i32);
6529 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES: Self = Self(1000273000i32);
6530 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES: Self = Self(
6531 1000277000i32,
6532 );
6533 pub const GRAPHICS_SHADER_GROUP_CREATE_INFO: Self = Self(1000277001i32);
6534 pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO: Self = Self(1000277002i32);
6535 pub const INDIRECT_COMMANDS_LAYOUT_TOKEN: Self = Self(1000277003i32);
6536 pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO: Self = Self(1000277004i32);
6537 pub const GENERATED_COMMANDS_INFO: Self = Self(1000277005i32);
6538 pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO: Self = Self(1000277006i32);
6539 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES: Self = Self(
6540 1000277007i32,
6541 );
6542 pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES: Self = Self(
6543 1000278000i32,
6544 );
6545 pub const COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO: Self = Self(
6546 1000278001i32,
6547 );
6548 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES: Self = Self(
6550 1000281000i32,
6551 );
6552 pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO: Self = Self(
6553 1000282000i32,
6554 );
6555 pub const RENDER_PASS_TRANSFORM_BEGIN_INFO: Self = Self(1000282001i32);
6556 pub const PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES: Self = Self(1000283000i32);
6557 pub const DEPTH_BIAS_INFO: Self = Self(1000283001i32);
6558 pub const DEPTH_BIAS_REPRESENTATION_INFO: Self = Self(1000283002i32);
6559 pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES: Self = Self(1000284000i32);
6560 pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO: Self = Self(1000284001i32);
6561 pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA: Self = Self(1000284002i32);
6562 pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO: Self = Self(1000287000i32);
6563 pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES: Self = Self(1000287001i32);
6564 pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES: Self = Self(1000287002i32);
6565 pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES: Self = Self(
6566 1000288000i32,
6567 );
6568 pub const PIPELINE_LIBRARY_CREATE_INFO: Self = Self(1000290000i32);
6569 pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES: Self = Self(1000292000i32);
6570 pub const SURFACE_CAPABILITIES_PRESENT_BARRIER: Self = Self(1000292001i32);
6571 pub const SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO: Self = Self(1000292002i32);
6572 pub const PRESENT_ID: Self = Self(1000294000i32);
6573 pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES: Self = Self(1000294001i32);
6574 pub const VIDEO_ENCODE_INFO: Self = Self(1000299000i32);
6575 pub const VIDEO_ENCODE_RATE_CONTROL_INFO: Self = Self(1000299001i32);
6576 pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO: Self = Self(1000299002i32);
6577 pub const VIDEO_ENCODE_CAPABILITIES: Self = Self(1000299003i32);
6578 pub const VIDEO_ENCODE_USAGE_INFO: Self = Self(1000299004i32);
6579 pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO: Self = Self(1000299005i32);
6580 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO: Self = Self(
6581 1000299006i32,
6582 );
6583 pub const VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES: Self = Self(1000299007i32);
6584 pub const VIDEO_ENCODE_QUALITY_LEVEL_INFO: Self = Self(1000299008i32);
6585 pub const VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO: Self = Self(1000299009i32);
6586 pub const VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO: Self = Self(1000299010i32);
6587 pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES: Self = Self(1000300000i32);
6588 pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO: Self = Self(1000300001i32);
6589 pub const CUDA_MODULE_CREATE_INFO: Self = Self(1000307000i32);
6590 pub const CUDA_FUNCTION_CREATE_INFO: Self = Self(1000307001i32);
6591 pub const CUDA_LAUNCH_INFO: Self = Self(1000307002i32);
6592 pub const PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES: Self = Self(1000307003i32);
6593 pub const PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES: Self = Self(1000307004i32);
6594 pub const PHYSICAL_DEVICE_TILE_SHADING_FEATURES: Self = Self(1000309000i32);
6595 pub const PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES: Self = Self(1000309001i32);
6596 pub const RENDER_PASS_TILE_SHADING_CREATE_INFO: Self = Self(1000309002i32);
6597 pub const PER_TILE_BEGIN_INFO: Self = Self(1000309003i32);
6598 pub const PER_TILE_END_INFO: Self = Self(1000309004i32);
6599 pub const DISPATCH_TILE_INFO: Self = Self(1000309005i32);
6600 pub const QUERY_LOW_LATENCY_SUPPORT: Self = Self(1000310000i32);
6601 pub const EXPORT_METAL_OBJECT_CREATE_INFO: Self = Self(1000311000i32);
6602 pub const EXPORT_METAL_OBJECTS_INFO: Self = Self(1000311001i32);
6603 pub const EXPORT_METAL_DEVICE_INFO: Self = Self(1000311002i32);
6604 pub const EXPORT_METAL_COMMAND_QUEUE_INFO: Self = Self(1000311003i32);
6605 pub const EXPORT_METAL_BUFFER_INFO: Self = Self(1000311004i32);
6606 pub const IMPORT_METAL_BUFFER_INFO: Self = Self(1000311005i32);
6607 pub const EXPORT_METAL_TEXTURE_INFO: Self = Self(1000311006i32);
6608 pub const IMPORT_METAL_TEXTURE_INFO: Self = Self(1000311007i32);
6609 pub const EXPORT_METAL_IO_SURFACE_INFO: Self = Self(1000311008i32);
6610 pub const IMPORT_METAL_IO_SURFACE_INFO: Self = Self(1000311009i32);
6611 pub const EXPORT_METAL_SHARED_EVENT_INFO: Self = Self(1000311010i32);
6612 pub const IMPORT_METAL_SHARED_EVENT_INFO: Self = Self(1000311011i32);
6613 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES: Self = Self(1000316000i32);
6614 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES: Self = Self(
6615 1000316001i32,
6616 );
6617 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES: Self = Self(1000316002i32);
6618 pub const DESCRIPTOR_ADDRESS_INFO: Self = Self(1000316003i32);
6619 pub const DESCRIPTOR_GET_INFO: Self = Self(1000316004i32);
6620 pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000316005i32);
6621 pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000316006i32);
6622 pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000316007i32);
6623 pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000316008i32);
6624 pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO: Self = Self(1000316010i32);
6625 pub const DESCRIPTOR_BUFFER_BINDING_INFO: Self = Self(1000316011i32);
6626 pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE: Self = Self(
6627 1000316012i32,
6628 );
6629 pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(
6630 1000316009i32,
6631 );
6632 pub const DEVICE_MEMORY_COPY: Self = Self(1000318000i32);
6633 pub const COPY_DEVICE_MEMORY_INFO: Self = Self(1000318001i32);
6634 pub const DEVICE_MEMORY_IMAGE_COPY: Self = Self(1000318002i32);
6635 pub const COPY_DEVICE_MEMORY_IMAGE_INFO: Self = Self(1000318003i32);
6636 pub const MEMORY_RANGE_BARRIERS_INFO: Self = Self(1000318004i32);
6637 pub const MEMORY_RANGE_BARRIER: Self = Self(1000318005i32);
6638 pub const PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES: Self = Self(
6639 1000318006i32,
6640 );
6641 pub const BIND_INDEX_BUFFER_3_INFO: Self = Self(1000318007i32);
6642 pub const BIND_VERTEX_BUFFER_3_INFO: Self = Self(1000318008i32);
6643 pub const DRAW_INDIRECT_2_INFO: Self = Self(1000318009i32);
6644 pub const DRAW_INDIRECT_COUNT_2_INFO: Self = Self(1000318010i32);
6645 pub const DISPATCH_INDIRECT_2_INFO: Self = Self(1000318011i32);
6646 pub const CONDITIONAL_RENDERING_BEGIN_INFO_2: Self = Self(1000318012i32);
6647 pub const BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO: Self = Self(1000318013i32);
6648 pub const MEMORY_MARKER_INFO: Self = Self(1000318014i32);
6649 pub const ACCELERATION_STRUCTURE_CREATE_INFO_2: Self = Self(1000318015i32);
6650 pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES: Self = Self(
6651 1000320000i32,
6652 );
6653 pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES: Self = Self(
6654 1000320001i32,
6655 );
6656 pub const GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO: Self = Self(1000320002i32);
6657 pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES: Self = Self(
6658 1000321000i32,
6659 );
6660 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES: Self = Self(
6661 1000322000i32,
6662 );
6663 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES: Self = Self(
6664 1000323000i32,
6665 );
6666 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES: Self = Self(
6667 1000326000i32,
6668 );
6669 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES: Self = Self(
6670 1000326001i32,
6671 );
6672 pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO: Self = Self(
6673 1000326002i32,
6674 );
6675 pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA: Self = Self(
6676 1000327000i32,
6677 );
6678 pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES: Self = Self(
6679 1000327001i32,
6680 );
6681 pub const ACCELERATION_STRUCTURE_MOTION_INFO: Self = Self(1000327002i32);
6682 pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES: Self = Self(
6683 1000330000i32,
6684 );
6685 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES: Self = Self(
6686 1000332000i32,
6687 );
6688 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES: Self = Self(
6689 1000332001i32,
6690 );
6691 pub const COPY_COMMAND_TRANSFORM_INFO: Self = Self(1000333000i32);
6692 pub const PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES: Self = Self(
6693 1000336000i32,
6694 );
6695 pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES: Self = Self(
6696 1000338000i32,
6697 );
6698 pub const IMAGE_COMPRESSION_CONTROL: Self = Self(1000338001i32);
6699 pub const IMAGE_COMPRESSION_PROPERTIES: Self = Self(1000338004i32);
6700 pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES: Self = Self(
6701 1000339000i32,
6702 );
6703 pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES: Self = Self(1000340000i32);
6704 pub const PHYSICAL_DEVICE_FAULT_FEATURES: Self = Self(1000341000i32);
6705 pub const DEVICE_FAULT_COUNTS: Self = Self(1000341001i32);
6706 pub const DEVICE_FAULT_INFO: Self = Self(1000341002i32);
6707 pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES: Self = Self(1000344000i32);
6708 pub const DIRECTFB_SURFACE_CREATE_INFO: Self = Self(1000346000i32);
6709 pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES: Self = Self(
6710 1000352000i32,
6711 );
6712 pub const VERTEX_INPUT_BINDING_DESCRIPTION_2: Self = Self(1000352001i32);
6713 pub const VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2: Self = Self(1000352002i32);
6714 pub const PHYSICAL_DEVICE_DRM_PROPERTIES: Self = Self(1000353000i32);
6715 pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES: Self = Self(
6716 1000354000i32,
6717 );
6718 pub const DEVICE_ADDRESS_BINDING_CALLBACK_DATA: Self = Self(1000354001i32);
6719 pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES: Self = Self(1000355000i32);
6720 pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO: Self = Self(
6721 1000355001i32,
6722 );
6723 pub const PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES: Self = Self(
6724 1000356000i32,
6725 );
6726 pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO: Self = Self(1000364000i32);
6727 pub const MEMORY_ZIRCON_HANDLE_PROPERTIES: Self = Self(1000364001i32);
6728 pub const MEMORY_GET_ZIRCON_HANDLE_INFO: Self = Self(1000364002i32);
6729 pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO: Self = Self(1000365000i32);
6730 pub const SEMAPHORE_GET_ZIRCON_HANDLE_INFO: Self = Self(1000365001i32);
6731 pub const BUFFER_COLLECTION_CREATE_INFO: Self = Self(1000366000i32);
6732 pub const IMPORT_MEMORY_BUFFER_COLLECTION: Self = Self(1000366001i32);
6733 pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO: Self = Self(1000366002i32);
6734 pub const BUFFER_COLLECTION_PROPERTIES: Self = Self(1000366003i32);
6735 pub const BUFFER_CONSTRAINTS_INFO: Self = Self(1000366004i32);
6736 pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO: Self = Self(1000366005i32);
6737 pub const IMAGE_CONSTRAINTS_INFO: Self = Self(1000366006i32);
6738 pub const IMAGE_FORMAT_CONSTRAINTS_INFO: Self = Self(1000366007i32);
6739 pub const SYSMEM_COLOR_SPACE: Self = Self(1000366008i32);
6740 pub const BUFFER_COLLECTION_CONSTRAINTS_INFO: Self = Self(1000366009i32);
6741 pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO: Self = Self(1000369000i32);
6742 pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES: Self = Self(1000369001i32);
6743 pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES: Self = Self(1000369002i32);
6744 pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES: Self = Self(1000370000i32);
6745 pub const MEMORY_GET_REMOTE_ADDRESS_INFO: Self = Self(1000371000i32);
6746 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES: Self = Self(1000371001i32);
6747 pub const PIPELINE_PROPERTIES_IDENTIFIER: Self = Self(1000372000i32);
6748 pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES: Self = Self(1000372001i32);
6749 pub const PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES: Self = Self(1000375000i32);
6750 pub const FRAME_BOUNDARY: Self = Self(1000375001i32);
6751 pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES: Self = Self(
6752 1000376000i32,
6753 );
6754 pub const SUBPASS_RESOLVE_PERFORMANCE_QUERY: Self = Self(1000376001i32);
6755 pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO: Self = Self(1000376002i32);
6756 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES: Self = Self(
6758 1000377000i32,
6759 );
6760 pub const SCREEN_SURFACE_CREATE_INFO: Self = Self(1000378000i32);
6761 pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES: Self = Self(1000381000i32);
6762 pub const PIPELINE_COLOR_WRITE_CREATE_INFO: Self = Self(1000381001i32);
6763 pub const PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES: Self = Self(
6764 1000382000i32,
6765 );
6766 pub const PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES: Self = Self(
6767 1000386000i32,
6768 );
6769 pub const PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES: Self = Self(
6770 1000387000i32,
6771 );
6772 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES: Self = Self(
6773 1000390000i32,
6774 );
6775 pub const VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES: Self = Self(1000390001i32);
6776 pub const VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO: Self = Self(1000390002i32);
6777 pub const VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO: Self = Self(
6778 1000390003i32,
6779 );
6780 pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES: Self = Self(1000391000i32);
6781 pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO: Self = Self(1000391001i32);
6782 pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES: Self = Self(1000392000i32);
6783 pub const PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES: Self = Self(1000392001i32);
6784 pub const PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES: Self = Self(1000393000i32);
6785 pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES: Self = Self(1000395000i32);
6786 pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES: Self = Self(1000395001i32);
6787 pub const MICROMAP_BUILD_INFO: Self = Self(1000396000i32);
6788 pub const MICROMAP_VERSION_INFO: Self = Self(1000396001i32);
6789 pub const COPY_MICROMAP_INFO: Self = Self(1000396002i32);
6790 pub const COPY_MICROMAP_TO_MEMORY_INFO: Self = Self(1000396003i32);
6791 pub const COPY_MEMORY_TO_MICROMAP_INFO: Self = Self(1000396004i32);
6792 pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES: Self = Self(1000396005i32);
6793 pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES: Self = Self(1000396006i32);
6794 pub const MICROMAP_CREATE_INFO: Self = Self(1000396007i32);
6795 pub const MICROMAP_BUILD_SIZES_INFO: Self = Self(1000396008i32);
6796 pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP: Self = Self(
6797 1000396009i32,
6798 );
6799 pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES: Self = Self(1000397000i32);
6800 pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES: Self = Self(
6801 1000397001i32,
6802 );
6803 pub const ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP: Self = Self(
6804 1000397002i32,
6805 );
6806 pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES: Self = Self(
6807 1000404000i32,
6808 );
6809 pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES: Self = Self(
6810 1000404001i32,
6811 );
6812 pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES: Self = Self(
6813 1000404002i32,
6814 );
6815 pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES: Self = Self(1000411000i32);
6816 pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO: Self = Self(
6817 1000411001i32,
6818 );
6819 pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES: Self = Self(
6820 1000412000i32,
6821 );
6822 pub const DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO: Self = Self(1000417000i32);
6823 pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES: Self = Self(1000417001i32);
6824 pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES: Self = Self(1000417002i32);
6825 pub const PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES: Self = Self(
6826 1000418000i32,
6827 );
6828 pub const IMAGE_VIEW_SLICED_CREATE_INFO: Self = Self(1000418001i32);
6829 pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES: Self = Self(
6830 1000420000i32,
6831 );
6832 pub const DESCRIPTOR_SET_BINDING_REFERENCE: Self = Self(1000420001i32);
6833 pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO: Self = Self(1000420002i32);
6834 pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES: Self = Self(1000422000i32);
6835 pub const PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES: Self = Self(1000424000i32);
6836 pub const PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES: Self = Self(1000424001i32);
6837 pub const RENDER_PASS_STRIPE_BEGIN_INFO: Self = Self(1000424002i32);
6838 pub const RENDER_PASS_STRIPE_INFO: Self = Self(1000424003i32);
6839 pub const RENDER_PASS_STRIPE_SUBMIT_INFO: Self = Self(1000424004i32);
6840 pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO: Self = Self::RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO;
6841 pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES: Self = Self(1000426000i32);
6842 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES: Self = Self(
6843 1000428000i32,
6844 );
6845 pub const COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO: Self = Self(1000428001i32);
6846 pub const PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO: Self = Self(1000428002i32);
6847 pub const PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES: Self = Self(
6848 1000429008i32,
6849 );
6850 pub const ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA: Self = Self(
6851 1000429009i32,
6852 );
6853 pub const ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA: Self = Self(1000429010i32);
6854 pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES: Self = Self(
6855 1000430000i32,
6856 );
6857 pub const PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES: Self = Self(
6858 1000434000i32,
6859 );
6860 pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES: Self = Self(
6861 1000437000i32,
6862 );
6863 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES: Self = Self(1000440000i32);
6864 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES: Self = Self(1000440001i32);
6865 pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO: Self = Self(1000440002i32);
6866 pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES: Self = Self(1000451000i32);
6867 pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES: Self = Self(
6868 1000451001i32,
6869 );
6870 pub const NATIVE_BUFFER_USAGE: Self = Self(1000452000i32);
6871 pub const NATIVE_BUFFER_PROPERTIES: Self = Self(1000452001i32);
6872 pub const NATIVE_BUFFER_FORMAT_PROPERTIES: Self = Self(1000452002i32);
6873 pub const IMPORT_NATIVE_BUFFER_INFO: Self = Self(1000452003i32);
6874 pub const MEMORY_GET_NATIVE_BUFFER_INFO: Self = Self(1000452004i32);
6875 pub const EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED: Self = Self(1000453000i32);
6876 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES: Self = Self(
6877 1000455000i32,
6878 );
6879 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES: Self = Self(
6880 1000455001i32,
6881 );
6882 pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES: Self = Self(
6883 1000458000i32,
6884 );
6885 pub const RENDER_PASS_CREATION_CONTROL: Self = Self(1000458001i32);
6886 pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO: Self = Self(1000458002i32);
6887 pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO: Self = Self(1000458003i32);
6888 pub const DIRECT_DRIVER_LOADING_INFO: Self = Self(1000459000i32);
6889 pub const DIRECT_DRIVER_LOADING_LIST: Self = Self(1000459001i32);
6890 pub const TENSOR_CREATE_INFO: Self = Self(1000460000i32);
6891 pub const TENSOR_VIEW_CREATE_INFO: Self = Self(1000460001i32);
6892 pub const BIND_TENSOR_MEMORY_INFO: Self = Self(1000460002i32);
6893 pub const WRITE_DESCRIPTOR_SET_TENSOR: Self = Self(1000460003i32);
6894 pub const PHYSICAL_DEVICE_TENSOR_PROPERTIES: Self = Self(1000460004i32);
6895 pub const TENSOR_FORMAT_PROPERTIES: Self = Self(1000460005i32);
6896 pub const TENSOR_DESCRIPTION: Self = Self(1000460006i32);
6897 pub const TENSOR_MEMORY_REQUIREMENTS_INFO: Self = Self(1000460007i32);
6898 pub const TENSOR_MEMORY_BARRIER: Self = Self(1000460008i32);
6899 pub const PHYSICAL_DEVICE_TENSOR_FEATURES: Self = Self(1000460009i32);
6900 pub const DEVICE_TENSOR_MEMORY_REQUIREMENTS: Self = Self(1000460010i32);
6901 pub const COPY_TENSOR_INFO: Self = Self(1000460011i32);
6902 pub const TENSOR_COPY: Self = Self(1000460012i32);
6903 pub const TENSOR_DEPENDENCY_INFO: Self = Self(1000460013i32);
6904 pub const MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR: Self = Self(1000460014i32);
6905 pub const PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO: Self = Self(1000460015i32);
6906 pub const EXTERNAL_TENSOR_PROPERTIES: Self = Self(1000460016i32);
6907 pub const EXTERNAL_MEMORY_TENSOR_CREATE_INFO: Self = Self(1000460017i32);
6908 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES: Self = Self(
6909 1000460018i32,
6910 );
6911 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES: Self = Self(
6912 1000460019i32,
6913 );
6914 pub const DESCRIPTOR_GET_TENSOR_INFO: Self = Self(1000460020i32);
6915 pub const TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000460021i32);
6916 pub const TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000460022i32);
6917 pub const FRAME_BOUNDARY_TENSORS: Self = Self(1000460023i32);
6918 pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES: Self = Self(
6919 1000462000i32,
6920 );
6921 pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES: Self = Self(
6922 1000462001i32,
6923 );
6924 pub const PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO: Self = Self(
6925 1000462002i32,
6926 );
6927 pub const SHADER_MODULE_IDENTIFIER: Self = Self(1000462003i32);
6928 pub const PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES: Self = Self(1000464000i32);
6929 pub const PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES: Self = Self(1000464001i32);
6930 pub const OPTICAL_FLOW_IMAGE_FORMAT_INFO: Self = Self(1000464002i32);
6931 pub const OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES: Self = Self(1000464003i32);
6932 pub const OPTICAL_FLOW_SESSION_CREATE_INFO: Self = Self(1000464004i32);
6933 pub const OPTICAL_FLOW_EXECUTE_INFO: Self = Self(1000464005i32);
6934 pub const OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO: Self = Self(1000464010i32);
6935 pub const PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES: Self = Self(1000465000i32);
6936 pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES: Self = Self(
6937 1000468000i32,
6938 );
6939 pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES: Self = Self(
6940 1000468001i32,
6941 );
6942 pub const ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES: Self = Self(
6943 1000468002i32,
6944 );
6945 pub const PHYSICAL_DEVICE_ANTI_LAG_FEATURES: Self = Self(1000476000i32);
6946 pub const ANTI_LAG_DATA: Self = Self(1000476001i32);
6947 pub const ANTI_LAG_PRESENTATION_INFO: Self = Self(1000476002i32);
6948 pub const PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES: Self = Self(1000478000i32);
6949 pub const ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA: Self = Self(
6950 1000478001i32,
6951 );
6952 pub const SURFACE_CAPABILITIES_PRESENT_ID_2: Self = Self(1000479000i32);
6953 pub const PRESENT_ID_2: Self = Self(1000479001i32);
6954 pub const PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES: Self = Self(1000479002i32);
6955 pub const SURFACE_CAPABILITIES_PRESENT_WAIT_2: Self = Self(1000480000i32);
6956 pub const PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES: Self = Self(1000480001i32);
6957 pub const PRESENT_WAIT_2_INFO: Self = Self(1000480002i32);
6958 pub const PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES: Self = Self(
6959 1000481000i32,
6960 );
6961 pub const PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES: Self = Self(1000482000i32);
6962 pub const PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES: Self = Self(1000482001i32);
6963 pub const SHADER_CREATE_INFO: Self = Self(1000482002i32);
6964 pub const SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: Self = Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
6965 pub const PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES: Self = Self(1000483000i32);
6966 pub const PIPELINE_BINARY_CREATE_INFO: Self = Self(1000483001i32);
6967 pub const PIPELINE_BINARY_INFO: Self = Self(1000483002i32);
6968 pub const PIPELINE_BINARY_KEY: Self = Self(1000483003i32);
6969 pub const PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES: Self = Self(1000483004i32);
6970 pub const RELEASE_CAPTURED_PIPELINE_DATA_INFO: Self = Self(1000483005i32);
6971 pub const PIPELINE_BINARY_DATA_INFO: Self = Self(1000483006i32);
6972 pub const PIPELINE_CREATE_INFO: Self = Self(1000483007i32);
6973 pub const DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL: Self = Self(1000483008i32);
6974 pub const PIPELINE_BINARY_HANDLES_INFO: Self = Self(1000483009i32);
6975 pub const PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES: Self = Self(1000484000i32);
6976 pub const TILE_PROPERTIES: Self = Self(1000484001i32);
6977 pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES: Self = Self(1000485000i32);
6978 pub const AMIGO_PROFILING_SUBMIT_INFO: Self = Self(1000485001i32);
6979 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES: Self = Self(
6980 1000488000i32,
6981 );
6982 pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES: Self = Self(
6983 1000490000i32,
6984 );
6985 pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES: Self = Self(
6986 1000490001i32,
6987 );
6988 pub const PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES: Self = Self(1000491000i32);
6989 pub const PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES: Self = Self(1000491001i32);
6990 pub const COOPERATIVE_VECTOR_PROPERTIES: Self = Self(1000491002i32);
6991 pub const CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO: Self = Self(1000491004i32);
6992 pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES: Self = Self(
6993 1000492000i32,
6994 );
6995 pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES: Self = Self(
6996 1000492001i32,
6997 );
6998 pub const PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES: Self = Self(
6999 1000495000i32,
7000 );
7001 pub const PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES: Self = Self(
7002 1000495001i32,
7003 );
7004 pub const LAYER_SETTINGS_CREATE_INFO: Self = Self(1000496000i32);
7005 pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES: Self = Self(1000497000i32);
7006 pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES: Self = Self(
7007 1000497001i32,
7008 );
7009 pub const PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES: Self = Self(
7010 1000498000i32,
7011 );
7012 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES: Self = Self(
7013 1000499000i32,
7014 );
7015 pub const PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES: Self = Self(
7016 1000504000i32,
7017 );
7018 pub const LATENCY_SLEEP_MODE_INFO: Self = Self(1000505000i32);
7019 pub const LATENCY_SLEEP_INFO: Self = Self(1000505001i32);
7020 pub const SET_LATENCY_MARKER_INFO: Self = Self(1000505002i32);
7021 pub const GET_LATENCY_MARKER_INFO: Self = Self(1000505003i32);
7022 pub const LATENCY_TIMINGS_FRAME_REPORT: Self = Self(1000505004i32);
7023 pub const LATENCY_SUBMISSION_PRESENT_ID: Self = Self(1000505005i32);
7024 pub const OUT_OF_BAND_QUEUE_TYPE_INFO: Self = Self(1000505006i32);
7025 pub const SWAPCHAIN_LATENCY_CREATE_INFO: Self = Self(1000505007i32);
7026 pub const LATENCY_SURFACE_CAPABILITIES: Self = Self(1000505008i32);
7027 pub const DATA_GRAPH_PIPELINE_CREATE_INFO: Self = Self(1000507000i32);
7028 pub const DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO: Self = Self(1000507001i32);
7029 pub const DATA_GRAPH_PIPELINE_RESOURCE_INFO: Self = Self(1000507002i32);
7030 pub const DATA_GRAPH_PIPELINE_CONSTANT: Self = Self(1000507003i32);
7031 pub const DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO: Self = Self(
7032 1000507004i32,
7033 );
7034 pub const BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO: Self = Self(1000507005i32);
7035 pub const PHYSICAL_DEVICE_DATA_GRAPH_FEATURES: Self = Self(1000507006i32);
7036 pub const DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO: Self = Self(1000507007i32);
7037 pub const DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT: Self = Self(1000507008i32);
7038 pub const DATA_GRAPH_PIPELINE_INFO: Self = Self(1000507009i32);
7039 pub const DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO: Self = Self(
7040 1000507010i32,
7041 );
7042 pub const DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO: Self = Self(
7043 1000507011i32,
7044 );
7045 pub const DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT: Self = Self(
7046 1000507012i32,
7047 );
7048 pub const DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO: Self = Self(1000507013i32);
7049 pub const DATA_GRAPH_PIPELINE_DISPATCH_INFO: Self = Self(1000507014i32);
7050 pub const DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO: Self = Self(1000507016i32);
7051 pub const QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES: Self = Self(
7052 1000507017i32,
7053 );
7054 pub const QUEUE_FAMILY_DATA_GRAPH_PROPERTIES: Self = Self(1000507018i32);
7055 pub const PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO: Self = Self(
7056 1000507019i32,
7057 );
7058 pub const DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO: Self = Self(
7059 1000507015i32,
7060 );
7061 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES: Self = Self(
7062 1000510000i32,
7063 );
7064 pub const MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO: Self = Self(
7065 1000510001i32,
7066 );
7067 pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES: Self = Self(
7068 1000511000i32,
7069 );
7070 pub const VIDEO_DECODE_AV1_CAPABILITIES: Self = Self(1000512000i32);
7071 pub const VIDEO_DECODE_AV1_PICTURE_INFO: Self = Self(1000512001i32);
7072 pub const VIDEO_DECODE_AV1_PROFILE_INFO: Self = Self(1000512003i32);
7073 pub const VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7074 1000512004i32,
7075 );
7076 pub const VIDEO_DECODE_AV1_DPB_SLOT_INFO: Self = Self(1000512005i32);
7077 pub const VIDEO_ENCODE_AV1_CAPABILITIES: Self = Self(1000513000i32);
7078 pub const VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7079 1000513001i32,
7080 );
7081 pub const VIDEO_ENCODE_AV1_PICTURE_INFO: Self = Self(1000513002i32);
7082 pub const VIDEO_ENCODE_AV1_DPB_SLOT_INFO: Self = Self(1000513003i32);
7083 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES: Self = Self(1000513004i32);
7084 pub const VIDEO_ENCODE_AV1_PROFILE_INFO: Self = Self(1000513005i32);
7085 pub const VIDEO_ENCODE_AV1_RATE_CONTROL_INFO: Self = Self(1000513006i32);
7086 pub const VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO: Self = Self(1000513007i32);
7087 pub const VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES: Self = Self(1000513008i32);
7088 pub const VIDEO_ENCODE_AV1_SESSION_CREATE_INFO: Self = Self(1000513009i32);
7089 pub const VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO: Self = Self(1000513010i32);
7090 pub const PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES: Self = Self(1000514000i32);
7091 pub const VIDEO_DECODE_VP9_CAPABILITIES: Self = Self(1000514001i32);
7092 pub const VIDEO_DECODE_VP9_PICTURE_INFO: Self = Self(1000514002i32);
7093 pub const VIDEO_DECODE_VP9_PROFILE_INFO: Self = Self(1000514003i32);
7094 pub const PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES: Self = Self(1000515000i32);
7095 pub const VIDEO_INLINE_QUERY_INFO: Self = Self(1000515001i32);
7096 pub const PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES: Self = Self(
7097 1000516000i32,
7098 );
7099 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES: Self = Self(1000518000i32);
7100 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES: Self = Self(1000518001i32);
7101 pub const SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO: Self = Self(1000518002i32);
7102 pub const SAMPLER_CUBIC_WEIGHTS_CREATE_INFO: Self = Self(1000519000i32);
7103 pub const PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES: Self = Self(1000519001i32);
7104 pub const BLIT_IMAGE_CUBIC_WEIGHTS_INFO: Self = Self(1000519002i32);
7105 pub const PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES: Self = Self(1000520000i32);
7106 pub const SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO: Self = Self(
7107 1000520001i32,
7108 );
7109 pub const PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES: Self = Self(1000521000i32);
7110 pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES: Self = Self(
7111 1000524000i32,
7112 );
7113 pub const PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES: Self = Self(1000527000i32);
7114 pub const ATTACHMENT_FEEDBACK_LOOP_INFO: Self = Self(1000527001i32);
7115 pub const SCREEN_BUFFER_PROPERTIES: Self = Self(1000529000i32);
7116 pub const SCREEN_BUFFER_FORMAT_PROPERTIES: Self = Self(1000529001i32);
7117 pub const IMPORT_SCREEN_BUFFER_INFO: Self = Self(1000529002i32);
7118 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES: Self = Self(
7119 1000529004i32,
7120 );
7121 pub const PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES: Self = Self(1000530000i32);
7122 pub const SET_DESCRIPTOR_BUFFER_OFFSETS_INFO: Self = Self(1000545007i32);
7123 pub const BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO: Self = Self(1000545008i32);
7124 pub const PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES: Self = Self(
7125 1000546000i32,
7126 );
7127 pub const PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES: Self = Self(1000547000i32);
7128 pub const PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES: Self = Self(1000547001i32);
7129 pub const TILE_MEMORY_REQUIREMENTS: Self = Self(1000547002i32);
7130 pub const TILE_MEMORY_BIND_INFO: Self = Self(1000547003i32);
7131 pub const TILE_MEMORY_SIZE_INFO: Self = Self(1000547004i32);
7132 pub const COPY_MEMORY_INDIRECT_INFO: Self = Self(1000549002i32);
7133 pub const COPY_MEMORY_TO_IMAGE_INDIRECT_INFO: Self = Self(1000549003i32);
7134 pub const DECOMPRESS_MEMORY_INFO: Self = Self(1000550002i32);
7135 pub const DISPLAY_SURFACE_STEREO_CREATE_INFO: Self = Self(1000551000i32);
7136 pub const DISPLAY_MODE_STEREO_PROPERTIES: Self = Self(1000551001i32);
7137 pub const VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES: Self = Self(1000552000i32);
7138 pub const VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO: Self = Self(1000552001i32);
7139 pub const VIDEO_ENCODE_INTRA_REFRESH_INFO: Self = Self(1000552002i32);
7140 pub const VIDEO_REFERENCE_INTRA_REFRESH_INFO: Self = Self(1000552003i32);
7141 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES: Self = Self(
7142 1000552004i32,
7143 );
7144 pub const VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES: Self = Self(1000553000i32);
7145 pub const VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES: Self = Self(1000553001i32);
7146 pub const VIDEO_ENCODE_QUANTIZATION_MAP_INFO: Self = Self(1000553002i32);
7147 pub const VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7148 1000553005i32,
7149 );
7150 pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES: Self = Self(
7151 1000553009i32,
7152 );
7153 pub const VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES: Self = Self(
7154 1000553003i32,
7155 );
7156 pub const VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES: Self = Self(
7157 1000553004i32,
7158 );
7159 pub const VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES: Self = Self(1000553006i32);
7160 pub const VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES: Self = Self(1000553007i32);
7161 pub const VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES: Self = Self(1000553008i32);
7162 pub const PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES: Self = Self(1000555000i32);
7163 pub const EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO: Self = Self(1000556000i32);
7164 pub const EXTERNAL_COMPUTE_QUEUE_CREATE_INFO: Self = Self(1000556001i32);
7165 pub const EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS: Self = Self(1000556002i32);
7166 pub const PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES: Self = Self(
7167 1000556003i32,
7168 );
7169 pub const PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES: Self = Self(
7170 1000558000i32,
7171 );
7172 pub const PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES: Self = Self(
7173 1000559000i32,
7174 );
7175 pub const PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES: Self = Self(1000562000i32);
7176 pub const PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES: Self = Self(1000562001i32);
7177 pub const PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST: Self = Self(1000562002i32);
7178 pub const PHYSICAL_DEVICE_LAYERED_API_PROPERTIES: Self = Self(1000562003i32);
7179 pub const PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES: Self = Self(1000562004i32);
7180 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES: Self = Self(
7181 1000563000i32,
7182 );
7183 pub const PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES: Self = Self(
7184 1000564000i32,
7185 );
7186 pub const PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES: Self = Self(1000567000i32);
7187 pub const PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES: Self = Self(
7188 1000568000i32,
7189 );
7190 pub const PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES: Self = Self(
7191 1000569000i32,
7192 );
7193 pub const PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES: Self = Self(
7194 1000569001i32,
7195 );
7196 pub const CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT: Self = Self(
7197 1000569002i32,
7198 );
7199 pub const CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT: Self = Self(
7200 1000569003i32,
7201 );
7202 pub const CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT: Self = Self(
7203 1000569004i32,
7204 );
7205 pub const CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO: Self = Self(1000569005i32);
7206 pub const CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO: Self = Self(1000569006i32);
7207 pub const RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO: Self = Self(
7208 1000569007i32,
7209 );
7210 pub const PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES: Self = Self(
7211 1000570000i32,
7212 );
7213 pub const PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES: Self = Self(
7214 1000570001i32,
7215 );
7216 pub const WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE: Self = Self(
7217 1000570002i32,
7218 );
7219 pub const PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT: Self = Self(
7220 1000570003i32,
7221 );
7222 pub const BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO: Self = Self(1000570004i32);
7223 pub const PARTITIONED_ACCELERATION_STRUCTURE_FLAGS: Self = Self(1000570005i32);
7224 pub const INDIRECT_EXECUTION_SET_CREATE_INFO: Self = Self(1000572003i32);
7225 pub const WRITE_INDIRECT_EXECUTION_SET_PIPELINE: Self = Self(1000572008i32);
7226 pub const WRITE_INDIRECT_EXECUTION_SET_SHADER: Self = Self(1000572009i32);
7227 pub const INDIRECT_EXECUTION_SET_PIPELINE_INFO: Self = Self(1000572010i32);
7228 pub const INDIRECT_EXECUTION_SET_SHADER_INFO: Self = Self(1000572011i32);
7229 pub const INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO: Self = Self(1000572012i32);
7230 pub const GENERATED_COMMANDS_PIPELINE_INFO: Self = Self(1000572013i32);
7231 pub const GENERATED_COMMANDS_SHADER_INFO: Self = Self(1000572014i32);
7232 pub const PHYSICAL_DEVICE_FAULT_PROPERTIES: Self = Self(1000573001i32);
7233 pub const DEVICE_FAULT_DEBUG_INFO: Self = Self(1000573003i32);
7234 pub const PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES: Self = Self(1000574000i32);
7235 pub const MEMORY_BARRIER_ACCESS_FLAGS_3: Self = Self(1000574002i32);
7236 pub const PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES: Self = Self(
7237 1000575000i32,
7238 );
7239 pub const PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES: Self = Self(
7240 1000575001i32,
7241 );
7242 pub const IMAGE_ALIGNMENT_CONTROL_CREATE_INFO: Self = Self(1000575002i32);
7243 pub const PHYSICAL_DEVICE_SHADER_FMA_FEATURES: Self = Self(1000579000i32);
7244 pub const PUSH_CONSTANT_BANK_INFO: Self = Self(1000580000i32);
7245 pub const PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES: Self = Self(1000580001i32);
7246 pub const PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES: Self = Self(1000580002i32);
7247 pub const PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES: Self = Self(1000582000i32);
7248 pub const PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO: Self = Self(
7249 1000582001i32,
7250 );
7251 pub const PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES: Self = Self(1000584000i32);
7252 pub const PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES: Self = Self(1000584001i32);
7253 pub const QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES: Self = Self(1000584002i32);
7254 pub const PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES: Self = Self(1000586000i32);
7255 pub const VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO: Self = Self(
7256 1000586001i32,
7257 );
7258 pub const VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO: Self = Self(
7259 1000586002i32,
7260 );
7261 pub const VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO: Self = Self(
7262 1000586003i32,
7263 );
7264 pub const SURFACE_CREATE_INFO: Self = Self(1000685000i32);
7265 pub const PHYSICAL_DEVICE_HDR_VIVID_FEATURES: Self = Self(1000590000i32);
7266 pub const HDR_VIVID_DYNAMIC_METADATA: Self = Self(1000590001i32);
7267 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES: Self = Self(1000593000i32);
7268 pub const COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES: Self = Self(
7269 1000593001i32,
7270 );
7271 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES: Self = Self(
7272 1000593002i32,
7273 );
7274 pub const PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES: Self = Self(
7275 1000596000i32,
7276 );
7277 pub const IMPORT_MEMORY_METAL_HANDLE_INFO: Self = Self(1000602000i32);
7278 pub const MEMORY_METAL_HANDLE_PROPERTIES: Self = Self(1000602001i32);
7279 pub const MEMORY_GET_METAL_HANDLE_INFO: Self = Self(1000602002i32);
7280 pub const PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES: Self = Self(
7281 1000605000i32,
7282 );
7283 pub const PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES: Self = Self(
7284 1000605001i32,
7285 );
7286 pub const RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO: Self = Self(
7287 1000605004i32,
7288 );
7289 pub const PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES: Self = Self(
7290 1000607000i32,
7291 );
7292 pub const PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES: Self = Self(
7293 1000607001i32,
7294 );
7295 pub const SHADER_INSTRUMENTATION_CREATE_INFO: Self = Self(1000607002i32);
7296 pub const SHADER_INSTRUMENTATION_METRIC_DESCRIPTION: Self = Self(1000607003i32);
7297 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES: Self = Self(
7298 1000608000i32,
7299 );
7300 pub const PHYSICAL_DEVICE_FORMAT_PACK_FEATURES: Self = Self(1000609000i32);
7301 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES: Self = Self(
7302 1000611000i32,
7303 );
7304 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES: Self = Self(
7305 1000611001i32,
7306 );
7307 pub const PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO: Self = Self(
7308 1000611002i32,
7309 );
7310 pub const SET_PRESENT_CONFIG: Self = Self(1000613000i32);
7311 pub const PHYSICAL_DEVICE_PRESENT_METERING_FEATURES: Self = Self(1000613001i32);
7312 pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO: Self = Self(
7313 1000425002i32,
7314 );
7315 pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES: Self = Self(
7316 1000620000i32,
7317 );
7318 pub const PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES: Self = Self(
7319 1000627000i32,
7320 );
7321 pub const PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES: Self = Self(1000628000i32);
7322 pub const BEGIN_CUSTOM_RESOLVE_INFO: Self = Self(1000628001i32);
7323 pub const CUSTOM_RESOLVE_CREATE_INFO: Self = Self(1000628002i32);
7324 pub const PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES: Self = Self(1000629000i32);
7325 pub const DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO: Self = Self(1000629001i32);
7326 pub const PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES: Self = Self(1000630000i32);
7327 pub const PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES: Self = Self(1000630001i32);
7328 pub const RENDERING_ATTACHMENT_FLAGS_INFO: Self = Self(1000630002i32);
7329 pub const RESOLVE_IMAGE_MODE_INFO: Self = Self(1000630004i32);
7330 pub const PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES: Self = Self(1000635000i32);
7331 pub const PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES: Self = Self(1000635001i32);
7332 pub const PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES: Self = Self(
7333 1000637000i32,
7334 );
7335 pub const PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES: Self = Self(
7336 1000642000i32,
7337 );
7338 pub const COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS: Self = Self(1000645000i32);
7339 pub const PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES: Self = Self(
7340 1000645001i32,
7341 );
7342 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES: Self = Self(
7343 1000662000i32,
7344 );
7345 pub const UBM_SURFACE_CREATE_INFO: Self = Self(1000664000i32);
7346 pub const PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES: Self = Self(
7347 1000673000i32,
7348 );
7349 #[inline]
7350 pub const fn from_raw(value: i32) -> Self {
7351 Self(value)
7352 }
7353 #[inline]
7354 pub const fn as_raw(self) -> i32 {
7355 self.0
7356 }
7357}
7358impl core::fmt::Debug for StructureType {
7359 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7360 match self.0 {
7361 0i32 => f.write_str("APPLICATION_INFO"),
7362 1i32 => f.write_str("INSTANCE_CREATE_INFO"),
7363 2i32 => f.write_str("DEVICE_QUEUE_CREATE_INFO"),
7364 3i32 => f.write_str("DEVICE_CREATE_INFO"),
7365 4i32 => f.write_str("SUBMIT_INFO"),
7366 5i32 => f.write_str("MEMORY_ALLOCATE_INFO"),
7367 6i32 => f.write_str("MAPPED_MEMORY_RANGE"),
7368 7i32 => f.write_str("BIND_SPARSE_INFO"),
7369 8i32 => f.write_str("FENCE_CREATE_INFO"),
7370 9i32 => f.write_str("SEMAPHORE_CREATE_INFO"),
7371 10i32 => f.write_str("EVENT_CREATE_INFO"),
7372 11i32 => f.write_str("QUERY_POOL_CREATE_INFO"),
7373 12i32 => f.write_str("BUFFER_CREATE_INFO"),
7374 13i32 => f.write_str("BUFFER_VIEW_CREATE_INFO"),
7375 14i32 => f.write_str("IMAGE_CREATE_INFO"),
7376 15i32 => f.write_str("IMAGE_VIEW_CREATE_INFO"),
7377 16i32 => f.write_str("SHADER_MODULE_CREATE_INFO"),
7378 17i32 => f.write_str("PIPELINE_CACHE_CREATE_INFO"),
7379 18i32 => f.write_str("PIPELINE_SHADER_STAGE_CREATE_INFO"),
7380 19i32 => f.write_str("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"),
7381 20i32 => f.write_str("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"),
7382 21i32 => f.write_str("PIPELINE_TESSELLATION_STATE_CREATE_INFO"),
7383 22i32 => f.write_str("PIPELINE_VIEWPORT_STATE_CREATE_INFO"),
7384 23i32 => f.write_str("PIPELINE_RASTERIZATION_STATE_CREATE_INFO"),
7385 24i32 => f.write_str("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"),
7386 25i32 => f.write_str("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"),
7387 26i32 => f.write_str("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"),
7388 27i32 => f.write_str("PIPELINE_DYNAMIC_STATE_CREATE_INFO"),
7389 28i32 => f.write_str("GRAPHICS_PIPELINE_CREATE_INFO"),
7390 29i32 => f.write_str("COMPUTE_PIPELINE_CREATE_INFO"),
7391 30i32 => f.write_str("PIPELINE_LAYOUT_CREATE_INFO"),
7392 31i32 => f.write_str("SAMPLER_CREATE_INFO"),
7393 32i32 => f.write_str("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"),
7394 33i32 => f.write_str("DESCRIPTOR_POOL_CREATE_INFO"),
7395 34i32 => f.write_str("DESCRIPTOR_SET_ALLOCATE_INFO"),
7396 35i32 => f.write_str("WRITE_DESCRIPTOR_SET"),
7397 36i32 => f.write_str("COPY_DESCRIPTOR_SET"),
7398 37i32 => f.write_str("FRAMEBUFFER_CREATE_INFO"),
7399 38i32 => f.write_str("RENDER_PASS_CREATE_INFO"),
7400 39i32 => f.write_str("COMMAND_POOL_CREATE_INFO"),
7401 40i32 => f.write_str("COMMAND_BUFFER_ALLOCATE_INFO"),
7402 41i32 => f.write_str("COMMAND_BUFFER_INHERITANCE_INFO"),
7403 42i32 => f.write_str("COMMAND_BUFFER_BEGIN_INFO"),
7404 43i32 => f.write_str("RENDER_PASS_BEGIN_INFO"),
7405 44i32 => f.write_str("BUFFER_MEMORY_BARRIER"),
7406 45i32 => f.write_str("IMAGE_MEMORY_BARRIER"),
7407 46i32 => f.write_str("MEMORY_BARRIER"),
7408 47i32 => f.write_str("LOADER_INSTANCE_CREATE_INFO"),
7409 48i32 => f.write_str("LOADER_DEVICE_CREATE_INFO"),
7410 1000157000i32 => f.write_str("BIND_BUFFER_MEMORY_INFO"),
7411 1000157001i32 => f.write_str("BIND_IMAGE_MEMORY_INFO"),
7412 1000127000i32 => f.write_str("MEMORY_DEDICATED_REQUIREMENTS"),
7413 1000127001i32 => f.write_str("MEMORY_DEDICATED_ALLOCATE_INFO"),
7414 1000060000i32 => f.write_str("MEMORY_ALLOCATE_FLAGS_INFO"),
7415 1000060004i32 => f.write_str("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"),
7416 1000060005i32 => f.write_str("DEVICE_GROUP_SUBMIT_INFO"),
7417 1000060006i32 => f.write_str("DEVICE_GROUP_BIND_SPARSE_INFO"),
7418 1000060013i32 => f.write_str("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"),
7419 1000060014i32 => f.write_str("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"),
7420 1000070000i32 => f.write_str("PHYSICAL_DEVICE_GROUP_PROPERTIES"),
7421 1000070001i32 => f.write_str("DEVICE_GROUP_DEVICE_CREATE_INFO"),
7422 1000146000i32 => f.write_str("BUFFER_MEMORY_REQUIREMENTS_INFO_2"),
7423 1000146001i32 => f.write_str("IMAGE_MEMORY_REQUIREMENTS_INFO_2"),
7424 1000146002i32 => f.write_str("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2"),
7425 1000146003i32 => f.write_str("MEMORY_REQUIREMENTS_2"),
7426 1000146004i32 => f.write_str("SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"),
7427 1000059000i32 => f.write_str("PHYSICAL_DEVICE_FEATURES_2"),
7428 1000059001i32 => f.write_str("PHYSICAL_DEVICE_PROPERTIES_2"),
7429 1000059002i32 => f.write_str("FORMAT_PROPERTIES_2"),
7430 1000059003i32 => f.write_str("IMAGE_FORMAT_PROPERTIES_2"),
7431 1000059004i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"),
7432 1000059005i32 => f.write_str("QUEUE_FAMILY_PROPERTIES_2"),
7433 1000059006i32 => f.write_str("PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"),
7434 1000059007i32 => f.write_str("SPARSE_IMAGE_FORMAT_PROPERTIES_2"),
7435 1000059008i32 => f.write_str("PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2"),
7436 1000117002i32 => f.write_str("IMAGE_VIEW_USAGE_CREATE_INFO"),
7437 1000145000i32 => f.write_str("PROTECTED_SUBMIT_INFO"),
7438 1000145001i32 => f.write_str("PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"),
7439 1000145002i32 => f.write_str("PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"),
7440 1000145003i32 => f.write_str("DEVICE_QUEUE_INFO_2"),
7441 1000071000i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"),
7442 1000071001i32 => f.write_str("EXTERNAL_IMAGE_FORMAT_PROPERTIES"),
7443 1000071002i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"),
7444 1000071003i32 => f.write_str("EXTERNAL_BUFFER_PROPERTIES"),
7445 1000071004i32 => f.write_str("PHYSICAL_DEVICE_ID_PROPERTIES"),
7446 1000072000i32 => f.write_str("EXTERNAL_MEMORY_BUFFER_CREATE_INFO"),
7447 1000072001i32 => f.write_str("EXTERNAL_MEMORY_IMAGE_CREATE_INFO"),
7448 1000072002i32 => f.write_str("EXPORT_MEMORY_ALLOCATE_INFO"),
7449 1000112000i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"),
7450 1000112001i32 => f.write_str("EXTERNAL_FENCE_PROPERTIES"),
7451 1000113000i32 => f.write_str("EXPORT_FENCE_CREATE_INFO"),
7452 1000077000i32 => f.write_str("EXPORT_SEMAPHORE_CREATE_INFO"),
7453 1000076000i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"),
7454 1000076001i32 => f.write_str("EXTERNAL_SEMAPHORE_PROPERTIES"),
7455 1000094000i32 => f.write_str("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"),
7456 1000083000i32 => f.write_str("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"),
7457 1000120000i32 => f.write_str("PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"),
7458 1000085000i32 => f.write_str("DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO"),
7459 1000168000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"),
7460 1000168001i32 => f.write_str("DESCRIPTOR_SET_LAYOUT_SUPPORT"),
7461 1000156000i32 => f.write_str("SAMPLER_YCBCR_CONVERSION_CREATE_INFO"),
7462 1000156001i32 => f.write_str("SAMPLER_YCBCR_CONVERSION_INFO"),
7463 1000156002i32 => f.write_str("BIND_IMAGE_PLANE_MEMORY_INFO"),
7464 1000156003i32 => f.write_str("IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"),
7465 1000156004i32 => {
7466 f.write_str("PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES")
7467 }
7468 1000156005i32 => {
7469 f.write_str("SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES")
7470 }
7471 1000060003i32 => f.write_str("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"),
7472 1000117000i32 => f.write_str("PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"),
7473 1000117001i32 => {
7474 f.write_str("RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO")
7475 }
7476 1000117003i32 => {
7477 f.write_str("PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO")
7478 }
7479 1000053000i32 => f.write_str("RENDER_PASS_MULTIVIEW_CREATE_INFO"),
7480 1000053001i32 => f.write_str("PHYSICAL_DEVICE_MULTIVIEW_FEATURES"),
7481 1000053002i32 => f.write_str("PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"),
7482 1000063000i32 => {
7483 f.write_str("PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES")
7484 }
7485 1000196000i32 => f.write_str("PHYSICAL_DEVICE_DRIVER_PROPERTIES"),
7486 49i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"),
7487 50i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"),
7488 51i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"),
7489 52i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"),
7490 1000147000i32 => f.write_str("IMAGE_FORMAT_LIST_CREATE_INFO"),
7491 1000211000i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"),
7492 1000261000i32 => f.write_str("PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"),
7493 1000207000i32 => f.write_str("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"),
7494 1000207001i32 => f.write_str("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"),
7495 1000207002i32 => f.write_str("SEMAPHORE_TYPE_CREATE_INFO"),
7496 1000207003i32 => f.write_str("TIMELINE_SEMAPHORE_SUBMIT_INFO"),
7497 1000207004i32 => f.write_str("SEMAPHORE_WAIT_INFO"),
7498 1000207005i32 => f.write_str("SEMAPHORE_SIGNAL_INFO"),
7499 1000257000i32 => {
7500 f.write_str("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES")
7501 }
7502 1000244001i32 => f.write_str("BUFFER_DEVICE_ADDRESS_INFO"),
7503 1000257002i32 => f.write_str("BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"),
7504 1000257003i32 => f.write_str("MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"),
7505 1000257004i32 => f.write_str("DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"),
7506 1000177000i32 => f.write_str("PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"),
7507 1000180000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"),
7508 1000082000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"),
7509 1000197000i32 => f.write_str("PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"),
7510 1000161000i32 => {
7511 f.write_str("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO")
7512 }
7513 1000161001i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"),
7514 1000161002i32 => {
7515 f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES")
7516 }
7517 1000161003i32 => {
7518 f.write_str("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO")
7519 }
7520 1000161004i32 => {
7521 f.write_str("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT")
7522 }
7523 1000221000i32 => f.write_str("PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"),
7524 1000130000i32 => {
7525 f.write_str("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES")
7526 }
7527 1000130001i32 => f.write_str("SAMPLER_REDUCTION_MODE_CREATE_INFO"),
7528 1000253000i32 => {
7529 f.write_str("PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES")
7530 }
7531 1000175000i32 => {
7532 f.write_str("PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES")
7533 }
7534 1000109000i32 => f.write_str("ATTACHMENT_DESCRIPTION_2"),
7535 1000109001i32 => f.write_str("ATTACHMENT_REFERENCE_2"),
7536 1000109002i32 => f.write_str("SUBPASS_DESCRIPTION_2"),
7537 1000109003i32 => f.write_str("SUBPASS_DEPENDENCY_2"),
7538 1000109004i32 => f.write_str("RENDER_PASS_CREATE_INFO_2"),
7539 1000109005i32 => f.write_str("SUBPASS_BEGIN_INFO"),
7540 1000109006i32 => f.write_str("SUBPASS_END_INFO"),
7541 1000199000i32 => {
7542 f.write_str("PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES")
7543 }
7544 1000199001i32 => f.write_str("SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"),
7545 1000246000i32 => f.write_str("IMAGE_STENCIL_USAGE_CREATE_INFO"),
7546 1000108000i32 => {
7547 f.write_str("PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES")
7548 }
7549 1000108001i32 => f.write_str("FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"),
7550 1000108002i32 => f.write_str("FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"),
7551 1000108003i32 => f.write_str("RENDER_PASS_ATTACHMENT_BEGIN_INFO"),
7552 1000241000i32 => {
7553 f.write_str("PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES")
7554 }
7555 1000241001i32 => f.write_str("ATTACHMENT_REFERENCE_STENCIL_LAYOUT"),
7556 1000241002i32 => f.write_str("ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"),
7557 53i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_3_FEATURES"),
7558 54i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES"),
7559 1000245000i32 => f.write_str("PHYSICAL_DEVICE_TOOL_PROPERTIES"),
7560 1000295000i32 => f.write_str("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES"),
7561 1000295001i32 => f.write_str("DEVICE_PRIVATE_DATA_CREATE_INFO"),
7562 1000295002i32 => f.write_str("PRIVATE_DATA_SLOT_CREATE_INFO"),
7563 1000314000i32 => f.write_str("MEMORY_BARRIER_2"),
7564 1000314001i32 => f.write_str("BUFFER_MEMORY_BARRIER_2"),
7565 1000314002i32 => f.write_str("IMAGE_MEMORY_BARRIER_2"),
7566 1000314003i32 => f.write_str("DEPENDENCY_INFO"),
7567 1000314004i32 => f.write_str("SUBMIT_INFO_2"),
7568 1000314005i32 => f.write_str("SEMAPHORE_SUBMIT_INFO"),
7569 1000314006i32 => f.write_str("COMMAND_BUFFER_SUBMIT_INFO"),
7570 1000314007i32 => f.write_str("PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES"),
7571 1000337000i32 => f.write_str("COPY_BUFFER_INFO_2"),
7572 1000337001i32 => f.write_str("COPY_IMAGE_INFO_2"),
7573 1000337002i32 => f.write_str("COPY_BUFFER_TO_IMAGE_INFO_2"),
7574 1000337003i32 => f.write_str("COPY_IMAGE_TO_BUFFER_INFO_2"),
7575 1000337006i32 => f.write_str("BUFFER_COPY_2"),
7576 1000337007i32 => f.write_str("IMAGE_COPY_2"),
7577 1000337009i32 => f.write_str("BUFFER_IMAGE_COPY_2"),
7578 1000066000i32 => {
7579 f.write_str("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES")
7580 }
7581 1000360000i32 => f.write_str("FORMAT_PROPERTIES_3"),
7582 1000413000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES"),
7583 1000413001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES"),
7584 1000413002i32 => f.write_str("DEVICE_BUFFER_MEMORY_REQUIREMENTS"),
7585 1000413003i32 => f.write_str("DEVICE_IMAGE_MEMORY_REQUIREMENTS"),
7586 1000192000i32 => f.write_str("PIPELINE_CREATION_FEEDBACK_CREATE_INFO"),
7587 1000215000i32 => {
7588 f.write_str("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES")
7589 }
7590 1000276000i32 => {
7591 f.write_str(
7592 "PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES",
7593 )
7594 }
7595 1000297000i32 => {
7596 f.write_str("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES")
7597 }
7598 1000325000i32 => {
7599 f.write_str("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES")
7600 }
7601 1000335000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES"),
7602 1000225000i32 => {
7603 f.write_str("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES")
7604 }
7605 1000225001i32 => {
7606 f.write_str("PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO")
7607 }
7608 1000225002i32 => {
7609 f.write_str("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES")
7610 }
7611 1000138000i32 => f.write_str("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES"),
7612 1000138001i32 => {
7613 f.write_str("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES")
7614 }
7615 1000138002i32 => f.write_str("WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK"),
7616 1000138003i32 => {
7617 f.write_str("DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO")
7618 }
7619 1000280000i32 => {
7620 f.write_str("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES")
7621 }
7622 1000280001i32 => {
7623 f.write_str("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES")
7624 }
7625 1000281001i32 => {
7626 f.write_str("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES")
7627 }
7628 1000337004i32 => f.write_str("BLIT_IMAGE_INFO_2"),
7629 1000337005i32 => f.write_str("RESOLVE_IMAGE_INFO_2"),
7630 1000337008i32 => f.write_str("IMAGE_BLIT_2"),
7631 1000337010i32 => f.write_str("IMAGE_RESOLVE_2"),
7632 1000044000i32 => f.write_str("RENDERING_INFO"),
7633 1000044001i32 => f.write_str("RENDERING_ATTACHMENT_INFO"),
7634 1000044002i32 => f.write_str("PIPELINE_RENDERING_CREATE_INFO"),
7635 1000044003i32 => f.write_str("PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES"),
7636 1000044004i32 => f.write_str("COMMAND_BUFFER_INHERITANCE_RENDERING_INFO"),
7637 55i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_4_FEATURES"),
7638 56i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES"),
7639 1000174000i32 => f.write_str("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO"),
7640 1000388000i32 => {
7641 f.write_str("PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES")
7642 }
7643 1000388001i32 => f.write_str("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES"),
7644 1000265000i32 => f.write_str("PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES"),
7645 1000271000i32 => f.write_str("MEMORY_MAP_INFO"),
7646 1000271001i32 => f.write_str("MEMORY_UNMAP_INFO"),
7647 1000470000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES"),
7648 1000470001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES"),
7649 1000470004i32 => f.write_str("DEVICE_IMAGE_SUBRESOURCE_INFO"),
7650 1000338002i32 => f.write_str("SUBRESOURCE_LAYOUT_2"),
7651 1000338003i32 => f.write_str("IMAGE_SUBRESOURCE_2"),
7652 1000470006i32 => f.write_str("BUFFER_USAGE_FLAGS_2_CREATE_INFO"),
7653 1000545000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES"),
7654 1000545001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES"),
7655 1000545002i32 => f.write_str("BIND_MEMORY_STATUS"),
7656 1000270000i32 => f.write_str("PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES"),
7657 1000270001i32 => f.write_str("PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES"),
7658 1000270002i32 => f.write_str("MEMORY_TO_IMAGE_COPY"),
7659 1000270003i32 => f.write_str("IMAGE_TO_MEMORY_COPY"),
7660 1000270004i32 => f.write_str("COPY_IMAGE_TO_MEMORY_INFO"),
7661 1000270005i32 => f.write_str("COPY_MEMORY_TO_IMAGE_INFO"),
7662 1000270006i32 => f.write_str("HOST_IMAGE_LAYOUT_TRANSITION_INFO"),
7663 1000270007i32 => f.write_str("COPY_IMAGE_TO_IMAGE_INFO"),
7664 1000270008i32 => f.write_str("SUBRESOURCE_HOST_MEMCPY_SIZE"),
7665 1000270009i32 => f.write_str("HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY"),
7666 1000416000i32 => {
7667 f.write_str("PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES")
7668 }
7669 1000528000i32 => {
7670 f.write_str("PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES")
7671 }
7672 1000544000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES"),
7673 1000470005i32 => f.write_str("PIPELINE_CREATE_FLAGS_2_CREATE_INFO"),
7674 1000080000i32 => f.write_str("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES"),
7675 1000545003i32 => f.write_str("BIND_DESCRIPTOR_SETS_INFO"),
7676 1000545004i32 => f.write_str("PUSH_CONSTANTS_INFO"),
7677 1000545005i32 => f.write_str("PUSH_DESCRIPTOR_SET_INFO"),
7678 1000545006i32 => f.write_str("PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO"),
7679 1000466000i32 => {
7680 f.write_str("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES")
7681 }
7682 1000068000i32 => f.write_str("PIPELINE_ROBUSTNESS_CREATE_INFO"),
7683 1000068001i32 => f.write_str("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES"),
7684 1000068002i32 => {
7685 f.write_str("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES")
7686 }
7687 1000259000i32 => f.write_str("PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES"),
7688 1000259001i32 => f.write_str("PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO"),
7689 1000259002i32 => f.write_str("PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES"),
7690 1000525000i32 => {
7691 f.write_str("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES")
7692 }
7693 1000190001i32 => {
7694 f.write_str("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO")
7695 }
7696 1000190002i32 => {
7697 f.write_str("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES")
7698 }
7699 1000470003i32 => f.write_str("RENDERING_AREA_INFO"),
7700 1000232000i32 => {
7701 f.write_str("PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES")
7702 }
7703 1000232001i32 => f.write_str("RENDERING_ATTACHMENT_LOCATION_INFO"),
7704 1000232002i32 => f.write_str("RENDERING_INPUT_ATTACHMENT_INDEX_INFO"),
7705 1000298000i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES"),
7706 1000298001i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES"),
7707 1000298002i32 => f.write_str("DEVICE_OBJECT_RESERVATION_CREATE_INFO"),
7708 1000298003i32 => f.write_str("COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO"),
7709 1000298004i32 => f.write_str("COMMAND_POOL_MEMORY_CONSUMPTION"),
7710 1000298005i32 => f.write_str("PIPELINE_POOL_SIZE"),
7711 1000298007i32 => f.write_str("FAULT_DATA"),
7712 1000298008i32 => f.write_str("FAULT_CALLBACK_INFO"),
7713 1000298010i32 => f.write_str("PIPELINE_OFFLINE_CREATE_INFO"),
7714 1000001000i32 => f.write_str("SWAPCHAIN_CREATE_INFO"),
7715 1000001001i32 => f.write_str("PRESENT_INFO"),
7716 1000060007i32 => f.write_str("DEVICE_GROUP_PRESENT_CAPABILITIES"),
7717 1000060008i32 => f.write_str("IMAGE_SWAPCHAIN_CREATE_INFO"),
7718 1000060009i32 => f.write_str("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO"),
7719 1000060010i32 => f.write_str("ACQUIRE_NEXT_IMAGE_INFO"),
7720 1000060011i32 => f.write_str("DEVICE_GROUP_PRESENT_INFO"),
7721 1000060012i32 => f.write_str("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO"),
7722 1000002000i32 => f.write_str("DISPLAY_MODE_CREATE_INFO"),
7723 1000002001i32 => f.write_str("DISPLAY_SURFACE_CREATE_INFO"),
7724 1000003000i32 => f.write_str("DISPLAY_PRESENT_INFO"),
7725 1000004000i32 => f.write_str("XLIB_SURFACE_CREATE_INFO"),
7726 1000005000i32 => f.write_str("XCB_SURFACE_CREATE_INFO"),
7727 1000006000i32 => f.write_str("WAYLAND_SURFACE_CREATE_INFO"),
7728 1000008000i32 => f.write_str("ANDROID_SURFACE_CREATE_INFO"),
7729 1000009000i32 => f.write_str("WIN32_SURFACE_CREATE_INFO"),
7730 1000011000i32 => f.write_str("DEBUG_REPORT_CALLBACK_CREATE_INFO"),
7731 1000018000i32 => {
7732 f.write_str("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER")
7733 }
7734 1000022000i32 => f.write_str("DEBUG_MARKER_OBJECT_NAME_INFO"),
7735 1000022001i32 => f.write_str("DEBUG_MARKER_OBJECT_TAG_INFO"),
7736 1000022002i32 => f.write_str("DEBUG_MARKER_MARKER_INFO"),
7737 1000023000i32 => f.write_str("VIDEO_PROFILE_INFO"),
7738 1000023001i32 => f.write_str("VIDEO_CAPABILITIES"),
7739 1000023002i32 => f.write_str("VIDEO_PICTURE_RESOURCE_INFO"),
7740 1000023003i32 => f.write_str("VIDEO_SESSION_MEMORY_REQUIREMENTS"),
7741 1000023004i32 => f.write_str("BIND_VIDEO_SESSION_MEMORY_INFO"),
7742 1000023005i32 => f.write_str("VIDEO_SESSION_CREATE_INFO"),
7743 1000023006i32 => f.write_str("VIDEO_SESSION_PARAMETERS_CREATE_INFO"),
7744 1000023007i32 => f.write_str("VIDEO_SESSION_PARAMETERS_UPDATE_INFO"),
7745 1000023008i32 => f.write_str("VIDEO_BEGIN_CODING_INFO"),
7746 1000023009i32 => f.write_str("VIDEO_END_CODING_INFO"),
7747 1000023010i32 => f.write_str("VIDEO_CODING_CONTROL_INFO"),
7748 1000023011i32 => f.write_str("VIDEO_REFERENCE_SLOT_INFO"),
7749 1000023012i32 => f.write_str("QUEUE_FAMILY_VIDEO_PROPERTIES"),
7750 1000023013i32 => f.write_str("VIDEO_PROFILE_LIST_INFO"),
7751 1000023014i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_FORMAT_INFO"),
7752 1000023015i32 => f.write_str("VIDEO_FORMAT_PROPERTIES"),
7753 1000023016i32 => f.write_str("QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES"),
7754 1000024000i32 => f.write_str("VIDEO_DECODE_INFO"),
7755 1000024001i32 => f.write_str("VIDEO_DECODE_CAPABILITIES"),
7756 1000024002i32 => f.write_str("VIDEO_DECODE_USAGE_INFO"),
7757 1000026000i32 => f.write_str("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO"),
7758 1000026001i32 => f.write_str("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO"),
7759 1000026002i32 => f.write_str("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO"),
7760 1000028000i32 => f.write_str("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES"),
7761 1000028001i32 => f.write_str("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES"),
7762 1000028002i32 => {
7763 f.write_str("PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO")
7764 }
7765 1000029000i32 => f.write_str("CU_MODULE_CREATE_INFO"),
7766 1000029001i32 => f.write_str("CU_FUNCTION_CREATE_INFO"),
7767 1000029002i32 => f.write_str("CU_LAUNCH_INFO"),
7768 1000029004i32 => f.write_str("CU_MODULE_TEXTURING_MODE_CREATE_INFO"),
7769 1000030000i32 => f.write_str("IMAGE_VIEW_HANDLE_INFO"),
7770 1000030001i32 => f.write_str("IMAGE_VIEW_ADDRESS_PROPERTIES"),
7771 1000038000i32 => f.write_str("VIDEO_ENCODE_H264_CAPABILITIES"),
7772 1000038001i32 => {
7773 f.write_str("VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO")
7774 }
7775 1000038002i32 => f.write_str("VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO"),
7776 1000038003i32 => f.write_str("VIDEO_ENCODE_H264_PICTURE_INFO"),
7777 1000038004i32 => f.write_str("VIDEO_ENCODE_H264_DPB_SLOT_INFO"),
7778 1000038005i32 => f.write_str("VIDEO_ENCODE_H264_NALU_SLICE_INFO"),
7779 1000038006i32 => f.write_str("VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO"),
7780 1000038007i32 => f.write_str("VIDEO_ENCODE_H264_PROFILE_INFO"),
7781 1000038008i32 => f.write_str("VIDEO_ENCODE_H264_RATE_CONTROL_INFO"),
7782 1000038009i32 => f.write_str("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO"),
7783 1000038010i32 => f.write_str("VIDEO_ENCODE_H264_SESSION_CREATE_INFO"),
7784 1000038011i32 => f.write_str("VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES"),
7785 1000038012i32 => f.write_str("VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO"),
7786 1000038013i32 => {
7787 f.write_str("VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO")
7788 }
7789 1000039000i32 => f.write_str("VIDEO_ENCODE_H265_CAPABILITIES"),
7790 1000039001i32 => {
7791 f.write_str("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO")
7792 }
7793 1000039002i32 => f.write_str("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO"),
7794 1000039003i32 => f.write_str("VIDEO_ENCODE_H265_PICTURE_INFO"),
7795 1000039004i32 => f.write_str("VIDEO_ENCODE_H265_DPB_SLOT_INFO"),
7796 1000039005i32 => f.write_str("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO"),
7797 1000039006i32 => f.write_str("VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO"),
7798 1000039007i32 => f.write_str("VIDEO_ENCODE_H265_PROFILE_INFO"),
7799 1000039009i32 => f.write_str("VIDEO_ENCODE_H265_RATE_CONTROL_INFO"),
7800 1000039010i32 => f.write_str("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO"),
7801 1000039011i32 => f.write_str("VIDEO_ENCODE_H265_SESSION_CREATE_INFO"),
7802 1000039012i32 => f.write_str("VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES"),
7803 1000039013i32 => f.write_str("VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO"),
7804 1000039014i32 => {
7805 f.write_str("VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO")
7806 }
7807 1000040000i32 => f.write_str("VIDEO_DECODE_H264_CAPABILITIES"),
7808 1000040001i32 => f.write_str("VIDEO_DECODE_H264_PICTURE_INFO"),
7809 1000040003i32 => f.write_str("VIDEO_DECODE_H264_PROFILE_INFO"),
7810 1000040004i32 => {
7811 f.write_str("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO")
7812 }
7813 1000040005i32 => f.write_str("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO"),
7814 1000040006i32 => f.write_str("VIDEO_DECODE_H264_DPB_SLOT_INFO"),
7815 1000041000i32 => f.write_str("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES"),
7816 1000049000i32 => f.write_str("STREAM_DESCRIPTOR_SURFACE_CREATE_INFO"),
7817 1000050000i32 => f.write_str("PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES"),
7818 1000057000i32 => f.write_str("IMPORT_MEMORY_WIN32_HANDLE_INFO"),
7819 1000057001i32 => f.write_str("EXPORT_MEMORY_WIN32_HANDLE_INFO"),
7820 1000058000i32 => f.write_str("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO"),
7821 1000061000i32 => f.write_str("VALIDATION_FLAGS"),
7822 1000062000i32 => f.write_str("VI_SURFACE_CREATE_INFO"),
7823 1000067000i32 => f.write_str("IMAGE_VIEW_ASTC_DECODE_MODE"),
7824 1000067001i32 => f.write_str("PHYSICAL_DEVICE_ASTC_DECODE_FEATURES"),
7825 1000073002i32 => f.write_str("MEMORY_WIN32_HANDLE_PROPERTIES"),
7826 1000073003i32 => f.write_str("MEMORY_GET_WIN32_HANDLE_INFO"),
7827 1000074000i32 => f.write_str("IMPORT_MEMORY_FD_INFO"),
7828 1000074001i32 => f.write_str("MEMORY_FD_PROPERTIES"),
7829 1000074002i32 => f.write_str("MEMORY_GET_FD_INFO"),
7830 1000078000i32 => f.write_str("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO"),
7831 1000078001i32 => f.write_str("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO"),
7832 1000078002i32 => f.write_str("D3D12_FENCE_SUBMIT_INFO"),
7833 1000078003i32 => f.write_str("SEMAPHORE_GET_WIN32_HANDLE_INFO"),
7834 1000079000i32 => f.write_str("IMPORT_SEMAPHORE_FD_INFO"),
7835 1000079001i32 => f.write_str("SEMAPHORE_GET_FD_INFO"),
7836 1000081000i32 => {
7837 f.write_str("COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO")
7838 }
7839 1000081001i32 => {
7840 f.write_str("PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES")
7841 }
7842 1000081002i32 => f.write_str("CONDITIONAL_RENDERING_BEGIN_INFO"),
7843 1000084000i32 => f.write_str("PRESENT_REGIONS"),
7844 1000087000i32 => f.write_str("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO"),
7845 1000090000i32 => f.write_str("SURFACE_CAPABILITIES_2"),
7846 1000091000i32 => f.write_str("DISPLAY_POWER_INFO"),
7847 1000091001i32 => f.write_str("DEVICE_EVENT_INFO"),
7848 1000091002i32 => f.write_str("DISPLAY_EVENT_INFO"),
7849 1000091003i32 => f.write_str("SWAPCHAIN_COUNTER_CREATE_INFO"),
7850 1000092000i32 => f.write_str("PRESENT_TIMES_INFO"),
7851 1000097000i32 => {
7852 f.write_str("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES")
7853 }
7854 1000044009i32 => f.write_str("MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO"),
7855 1000098000i32 => f.write_str("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO"),
7856 1000099000i32 => f.write_str("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES"),
7857 1000099001i32 => f.write_str("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO"),
7858 1000101000i32 => {
7859 f.write_str("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES")
7860 }
7861 1000101001i32 => {
7862 f.write_str("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO")
7863 }
7864 1000102000i32 => f.write_str("PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES"),
7865 1000102001i32 => {
7866 f.write_str("PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO")
7867 }
7868 1000105000i32 => f.write_str("HDR_METADATA"),
7869 1000110000i32 => {
7870 f.write_str("PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES")
7871 }
7872 1000111000i32 => f.write_str("SHARED_PRESENT_SURFACE_CAPABILITIES"),
7873 1000114000i32 => f.write_str("IMPORT_FENCE_WIN32_HANDLE_INFO"),
7874 1000114001i32 => f.write_str("EXPORT_FENCE_WIN32_HANDLE_INFO"),
7875 1000114002i32 => f.write_str("FENCE_GET_WIN32_HANDLE_INFO"),
7876 1000115000i32 => f.write_str("IMPORT_FENCE_FD_INFO"),
7877 1000115001i32 => f.write_str("FENCE_GET_FD_INFO"),
7878 1000116000i32 => f.write_str("PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES"),
7879 1000116001i32 => f.write_str("PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES"),
7880 1000116002i32 => f.write_str("QUERY_POOL_PERFORMANCE_CREATE_INFO"),
7881 1000116003i32 => f.write_str("PERFORMANCE_QUERY_SUBMIT_INFO"),
7882 1000116004i32 => f.write_str("ACQUIRE_PROFILING_LOCK_INFO"),
7883 1000116005i32 => f.write_str("PERFORMANCE_COUNTER"),
7884 1000116006i32 => f.write_str("PERFORMANCE_COUNTER_DESCRIPTION"),
7885 1000116007i32 => f.write_str("PERFORMANCE_QUERY_RESERVATION_INFO"),
7886 1000119000i32 => f.write_str("PHYSICAL_DEVICE_SURFACE_INFO_2"),
7887 1000119002i32 => f.write_str("SURFACE_FORMAT_2"),
7888 1000121000i32 => f.write_str("DISPLAY_PROPERTIES_2"),
7889 1000121001i32 => f.write_str("DISPLAY_PLANE_PROPERTIES_2"),
7890 1000121002i32 => f.write_str("DISPLAY_MODE_PROPERTIES_2"),
7891 1000121003i32 => f.write_str("DISPLAY_PLANE_INFO_2"),
7892 1000121004i32 => f.write_str("DISPLAY_PLANE_CAPABILITIES_2"),
7893 1000122000i32 => f.write_str("IOS_SURFACE_CREATE_INFO"),
7894 1000123000i32 => f.write_str("MACOS_SURFACE_CREATE_INFO"),
7895 1000128000i32 => f.write_str("DEBUG_UTILS_OBJECT_NAME_INFO"),
7896 1000128001i32 => f.write_str("DEBUG_UTILS_OBJECT_TAG_INFO"),
7897 1000128002i32 => f.write_str("DEBUG_UTILS_LABEL"),
7898 1000128003i32 => f.write_str("DEBUG_UTILS_MESSENGER_CALLBACK_DATA"),
7899 1000128004i32 => f.write_str("DEBUG_UTILS_MESSENGER_CREATE_INFO"),
7900 1000129000i32 => f.write_str("ANDROID_HARDWARE_BUFFER_USAGE"),
7901 1000129001i32 => f.write_str("ANDROID_HARDWARE_BUFFER_PROPERTIES"),
7902 1000129002i32 => f.write_str("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES"),
7903 1000129003i32 => f.write_str("IMPORT_ANDROID_HARDWARE_BUFFER_INFO"),
7904 1000129004i32 => f.write_str("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO"),
7905 1000129005i32 => f.write_str("EXTERNAL_FORMAT"),
7906 1000129006i32 => f.write_str("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2"),
7907 1000134000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES"),
7908 1000134001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES"),
7909 1000134002i32 => f.write_str("EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE"),
7910 1000134003i32 => f.write_str("EXECUTION_GRAPH_PIPELINE_CREATE_INFO"),
7911 1000134004i32 => f.write_str("PIPELINE_SHADER_STAGE_NODE_CREATE_INFO"),
7912 1000135000i32 => f.write_str("TEXEL_BUFFER_DESCRIPTOR_INFO"),
7913 1000135001i32 => f.write_str("IMAGE_DESCRIPTOR_INFO"),
7914 1000135002i32 => f.write_str("RESOURCE_DESCRIPTOR_INFO"),
7915 1000135003i32 => f.write_str("BIND_HEAP_INFO"),
7916 1000135004i32 => f.write_str("PUSH_DATA_INFO"),
7917 1000135005i32 => f.write_str("DESCRIPTOR_SET_AND_BINDING_MAPPING"),
7918 1000135006i32 => {
7919 f.write_str("SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO")
7920 }
7921 1000135007i32 => f.write_str("OPAQUE_CAPTURE_DATA_CREATE_INFO"),
7922 1000135008i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES"),
7923 1000135009i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES"),
7924 1000135010i32 => {
7925 f.write_str("COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO")
7926 }
7927 1000135011i32 => f.write_str("SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO"),
7928 1000135012i32 => f.write_str("INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN"),
7929 1000135013i32 => f.write_str("SUBSAMPLED_IMAGE_FORMAT_PROPERTIES"),
7930 1000135014i32 => {
7931 f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES")
7932 }
7933 1000044008i32 => f.write_str("ATTACHMENT_SAMPLE_COUNT_INFO"),
7934 1000141000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES"),
7935 1000143000i32 => f.write_str("SAMPLE_LOCATIONS_INFO"),
7936 1000143001i32 => f.write_str("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO"),
7937 1000143002i32 => f.write_str("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO"),
7938 1000143003i32 => f.write_str("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES"),
7939 1000143004i32 => f.write_str("MULTISAMPLE_PROPERTIES"),
7940 1000148000i32 => {
7941 f.write_str("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES")
7942 }
7943 1000148001i32 => {
7944 f.write_str("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES")
7945 }
7946 1000148002i32 => {
7947 f.write_str("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO")
7948 }
7949 1000149000i32 => f.write_str("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO"),
7950 1000150007i32 => f.write_str("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE"),
7951 1000150000i32 => f.write_str("ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO"),
7952 1000150002i32 => f.write_str("ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO"),
7953 1000150003i32 => f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA"),
7954 1000150004i32 => {
7955 f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA")
7956 }
7957 1000150005i32 => {
7958 f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA")
7959 }
7960 1000150006i32 => f.write_str("ACCELERATION_STRUCTURE_GEOMETRY"),
7961 1000150009i32 => f.write_str("ACCELERATION_STRUCTURE_VERSION_INFO"),
7962 1000150010i32 => f.write_str("COPY_ACCELERATION_STRUCTURE_INFO"),
7963 1000150011i32 => f.write_str("COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO"),
7964 1000150012i32 => f.write_str("COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO"),
7965 1000150013i32 => {
7966 f.write_str("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES")
7967 }
7968 1000150014i32 => {
7969 f.write_str("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES")
7970 }
7971 1000150017i32 => f.write_str("ACCELERATION_STRUCTURE_CREATE_INFO"),
7972 1000150020i32 => f.write_str("ACCELERATION_STRUCTURE_BUILD_SIZES_INFO"),
7973 1000347000i32 => f.write_str("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES"),
7974 1000347001i32 => {
7975 f.write_str("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES")
7976 }
7977 1000150015i32 => f.write_str("RAY_TRACING_PIPELINE_CREATE_INFO"),
7978 1000150016i32 => f.write_str("RAY_TRACING_SHADER_GROUP_CREATE_INFO"),
7979 1000150018i32 => f.write_str("RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO"),
7980 1000348013i32 => f.write_str("PHYSICAL_DEVICE_RAY_QUERY_FEATURES"),
7981 1000152000i32 => {
7982 f.write_str("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO")
7983 }
7984 1000154000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES"),
7985 1000154001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES"),
7986 1000158000i32 => f.write_str("DRM_FORMAT_MODIFIER_PROPERTIES_LIST"),
7987 1000158002i32 => {
7988 f.write_str("PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO")
7989 }
7990 1000158003i32 => f.write_str("IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO"),
7991 1000158004i32 => {
7992 f.write_str("IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO")
7993 }
7994 1000158005i32 => f.write_str("IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES"),
7995 1000158006i32 => f.write_str("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2"),
7996 1000160000i32 => f.write_str("VALIDATION_CACHE_CREATE_INFO"),
7997 1000160001i32 => f.write_str("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO"),
7998 1000163000i32 => f.write_str("PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES"),
7999 1000163001i32 => f.write_str("PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES"),
8000 1000164000i32 => {
8001 f.write_str("PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO")
8002 }
8003 1000164001i32 => f.write_str("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES"),
8004 1000164002i32 => f.write_str("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES"),
8005 1000164005i32 => {
8006 f.write_str("PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO")
8007 }
8008 1000165003i32 => f.write_str("GEOMETRY"),
8009 1000165004i32 => f.write_str("GEOMETRY_TRIANGLES"),
8010 1000165005i32 => f.write_str("GEOMETRY_AABB"),
8011 1000165006i32 => f.write_str("BIND_ACCELERATION_STRUCTURE_MEMORY_INFO"),
8012 1000165008i32 => {
8013 f.write_str("ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO")
8014 }
8015 1000165009i32 => f.write_str("PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES"),
8016 1000165012i32 => f.write_str("ACCELERATION_STRUCTURE_INFO"),
8017 1000166000i32 => {
8018 f.write_str("PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES")
8019 }
8020 1000166001i32 => {
8021 f.write_str("PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO")
8022 }
8023 1000170000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO"),
8024 1000170001i32 => {
8025 f.write_str("FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES")
8026 }
8027 1000172000i32 => {
8028 f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES")
8029 }
8030 1000178000i32 => f.write_str("IMPORT_MEMORY_HOST_POINTER_INFO"),
8031 1000178001i32 => f.write_str("MEMORY_HOST_POINTER_PROPERTIES"),
8032 1000178002i32 => {
8033 f.write_str("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES")
8034 }
8035 1000181000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES"),
8036 1000183000i32 => f.write_str("PIPELINE_COMPILER_CONTROL_CREATE_INFO"),
8037 1000185000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES"),
8038 1000187000i32 => f.write_str("VIDEO_DECODE_H265_CAPABILITIES"),
8039 1000187001i32 => {
8040 f.write_str("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO")
8041 }
8042 1000187002i32 => f.write_str("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO"),
8043 1000187003i32 => f.write_str("VIDEO_DECODE_H265_PROFILE_INFO"),
8044 1000187004i32 => f.write_str("VIDEO_DECODE_H265_PICTURE_INFO"),
8045 1000187005i32 => f.write_str("VIDEO_DECODE_H265_DPB_SLOT_INFO"),
8046 1000189000i32 => f.write_str("DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO"),
8047 1000191000i32 => f.write_str("PRESENT_FRAME_TOKEN"),
8048 1000202000i32 => f.write_str("PHYSICAL_DEVICE_MESH_SHADER_FEATURES"),
8049 1000202001i32 => f.write_str("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES"),
8050 1000204000i32 => {
8051 f.write_str("PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES")
8052 }
8053 1000205000i32 => {
8054 f.write_str("PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO")
8055 }
8056 1000205002i32 => f.write_str("PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES"),
8057 1000206000i32 => f.write_str("CHECKPOINT_DATA"),
8058 1000206001i32 => f.write_str("QUEUE_FAMILY_CHECKPOINT_PROPERTIES"),
8059 1000314008i32 => f.write_str("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2"),
8060 1000314009i32 => f.write_str("CHECKPOINT_DATA_2"),
8061 1000208000i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES"),
8062 1000208001i32 => f.write_str("SWAPCHAIN_TIMING_PROPERTIES"),
8063 1000208002i32 => f.write_str("SWAPCHAIN_TIME_DOMAIN_PROPERTIES"),
8064 1000208003i32 => f.write_str("PRESENT_TIMINGS_INFO"),
8065 1000208004i32 => f.write_str("PRESENT_TIMING_INFO"),
8066 1000208005i32 => f.write_str("PAST_PRESENTATION_TIMING_INFO"),
8067 1000208006i32 => f.write_str("PAST_PRESENTATION_TIMING_PROPERTIES"),
8068 1000208007i32 => f.write_str("PAST_PRESENTATION_TIMING"),
8069 1000208008i32 => f.write_str("PRESENT_TIMING_SURFACE_CAPABILITIES"),
8070 1000208009i32 => f.write_str("SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO"),
8071 1000209000i32 => {
8072 f.write_str("PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES")
8073 }
8074 1000210000i32 => f.write_str("QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO"),
8075 1000210001i32 => f.write_str("INITIALIZE_PERFORMANCE_API_INFO"),
8076 1000210002i32 => f.write_str("PERFORMANCE_MARKER_INFO"),
8077 1000210003i32 => f.write_str("PERFORMANCE_STREAM_MARKER_INFO"),
8078 1000210004i32 => f.write_str("PERFORMANCE_OVERRIDE_INFO"),
8079 1000210005i32 => f.write_str("PERFORMANCE_CONFIGURATION_ACQUIRE_INFO"),
8080 1000212000i32 => f.write_str("PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES"),
8081 1000213000i32 => f.write_str("DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES"),
8082 1000213001i32 => f.write_str("SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO"),
8083 1000214000i32 => f.write_str("IMAGEPIPE_SURFACE_CREATE_INFO"),
8084 1000217000i32 => f.write_str("METAL_SURFACE_CREATE_INFO"),
8085 1000218000i32 => f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES"),
8086 1000218001i32 => {
8087 f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES")
8088 }
8089 1000218002i32 => f.write_str("RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO"),
8090 1000044007i32 => {
8091 f.write_str("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO")
8092 }
8093 1000226000i32 => f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT_INFO"),
8094 1000226001i32 => {
8095 f.write_str("PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO")
8096 }
8097 1000226002i32 => {
8098 f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES")
8099 }
8100 1000226003i32 => {
8101 f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES")
8102 }
8103 1000226004i32 => f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE"),
8104 1000044006i32 => {
8105 f.write_str("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO")
8106 }
8107 1000227000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2"),
8108 1000229000i32 => f.write_str("PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES"),
8109 1000231000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES"),
8110 1000233000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ABORT_FEATURES"),
8111 1000233001i32 => f.write_str("DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO"),
8112 1000233002i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES"),
8113 1000234000i32 => {
8114 f.write_str("PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES")
8115 }
8116 1000235000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES"),
8117 1000237000i32 => f.write_str("PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES"),
8118 1000238000i32 => f.write_str("PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES"),
8119 1000238001i32 => f.write_str("MEMORY_PRIORITY_ALLOCATE_INFO"),
8120 1000239000i32 => f.write_str("SURFACE_PROTECTED_CAPABILITIES"),
8121 1000240000i32 => {
8122 f.write_str(
8123 "PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES",
8124 )
8125 }
8126 1000244002i32 => f.write_str("BUFFER_DEVICE_ADDRESS_CREATE_INFO"),
8127 1000247000i32 => f.write_str("VALIDATION_FEATURES"),
8128 1000248000i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES"),
8129 1000249000i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES"),
8130 1000249001i32 => f.write_str("COOPERATIVE_MATRIX_PROPERTIES"),
8131 1000249002i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES"),
8132 1000250000i32 => {
8133 f.write_str("PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES")
8134 }
8135 1000250001i32 => f.write_str("PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO"),
8136 1000250002i32 => f.write_str("FRAMEBUFFER_MIXED_SAMPLES_COMBINATION"),
8137 1000251000i32 => {
8138 f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES")
8139 }
8140 1000252000i32 => f.write_str("PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES"),
8141 1000254000i32 => f.write_str("PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES"),
8142 1000254001i32 => {
8143 f.write_str("PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO")
8144 }
8145 1000254002i32 => f.write_str("PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES"),
8146 1000255000i32 => f.write_str("SURFACE_FULL_SCREEN_EXCLUSIVE_INFO"),
8147 1000255002i32 => f.write_str("SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE"),
8148 1000255001i32 => f.write_str("SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO"),
8149 1000256000i32 => f.write_str("HEADLESS_SURFACE_CREATE_INFO"),
8150 1000260000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES"),
8151 1000267000i32 => {
8152 f.write_str("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES")
8153 }
8154 1000269000i32 => {
8155 f.write_str("PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES")
8156 }
8157 1000269001i32 => f.write_str("PIPELINE_INFO"),
8158 1000269002i32 => f.write_str("PIPELINE_EXECUTABLE_PROPERTIES"),
8159 1000269003i32 => f.write_str("PIPELINE_EXECUTABLE_INFO"),
8160 1000269004i32 => f.write_str("PIPELINE_EXECUTABLE_STATISTIC"),
8161 1000269005i32 => f.write_str("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION"),
8162 1000272000i32 => f.write_str("PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES"),
8163 1000272001i32 => f.write_str("PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES"),
8164 1000272002i32 => f.write_str("MEMORY_MAP_PLACED_INFO"),
8165 1000273000i32 => {
8166 f.write_str("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES")
8167 }
8168 1000277000i32 => {
8169 f.write_str("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES")
8170 }
8171 1000277001i32 => f.write_str("GRAPHICS_SHADER_GROUP_CREATE_INFO"),
8172 1000277002i32 => f.write_str("GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO"),
8173 1000277003i32 => f.write_str("INDIRECT_COMMANDS_LAYOUT_TOKEN"),
8174 1000277004i32 => f.write_str("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO"),
8175 1000277005i32 => f.write_str("GENERATED_COMMANDS_INFO"),
8176 1000277006i32 => f.write_str("GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO"),
8177 1000277007i32 => {
8178 f.write_str("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES")
8179 }
8180 1000278000i32 => {
8181 f.write_str("PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES")
8182 }
8183 1000278001i32 => {
8184 f.write_str("COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO")
8185 }
8186 1000281000i32 => {
8187 f.write_str("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES")
8188 }
8189 1000282000i32 => {
8190 f.write_str("COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO")
8191 }
8192 1000282001i32 => f.write_str("RENDER_PASS_TRANSFORM_BEGIN_INFO"),
8193 1000283000i32 => f.write_str("PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES"),
8194 1000283001i32 => f.write_str("DEPTH_BIAS_INFO"),
8195 1000283002i32 => f.write_str("DEPTH_BIAS_REPRESENTATION_INFO"),
8196 1000284000i32 => f.write_str("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES"),
8197 1000284001i32 => f.write_str("DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO"),
8198 1000284002i32 => f.write_str("DEVICE_MEMORY_REPORT_CALLBACK_DATA"),
8199 1000287000i32 => f.write_str("SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO"),
8200 1000287001i32 => {
8201 f.write_str("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES")
8202 }
8203 1000287002i32 => f.write_str("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES"),
8204 1000288000i32 => {
8205 f.write_str("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES")
8206 }
8207 1000290000i32 => f.write_str("PIPELINE_LIBRARY_CREATE_INFO"),
8208 1000292000i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES"),
8209 1000292001i32 => f.write_str("SURFACE_CAPABILITIES_PRESENT_BARRIER"),
8210 1000292002i32 => f.write_str("SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO"),
8211 1000294000i32 => f.write_str("PRESENT_ID"),
8212 1000294001i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_ID_FEATURES"),
8213 1000299000i32 => f.write_str("VIDEO_ENCODE_INFO"),
8214 1000299001i32 => f.write_str("VIDEO_ENCODE_RATE_CONTROL_INFO"),
8215 1000299002i32 => f.write_str("VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO"),
8216 1000299003i32 => f.write_str("VIDEO_ENCODE_CAPABILITIES"),
8217 1000299004i32 => f.write_str("VIDEO_ENCODE_USAGE_INFO"),
8218 1000299005i32 => f.write_str("QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO"),
8219 1000299006i32 => {
8220 f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO")
8221 }
8222 1000299007i32 => f.write_str("VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES"),
8223 1000299008i32 => f.write_str("VIDEO_ENCODE_QUALITY_LEVEL_INFO"),
8224 1000299009i32 => f.write_str("VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO"),
8225 1000299010i32 => f.write_str("VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO"),
8226 1000300000i32 => f.write_str("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES"),
8227 1000300001i32 => f.write_str("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO"),
8228 1000307000i32 => f.write_str("CUDA_MODULE_CREATE_INFO"),
8229 1000307001i32 => f.write_str("CUDA_FUNCTION_CREATE_INFO"),
8230 1000307002i32 => f.write_str("CUDA_LAUNCH_INFO"),
8231 1000307003i32 => f.write_str("PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES"),
8232 1000307004i32 => f.write_str("PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES"),
8233 1000309000i32 => f.write_str("PHYSICAL_DEVICE_TILE_SHADING_FEATURES"),
8234 1000309001i32 => f.write_str("PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES"),
8235 1000309002i32 => f.write_str("RENDER_PASS_TILE_SHADING_CREATE_INFO"),
8236 1000309003i32 => f.write_str("PER_TILE_BEGIN_INFO"),
8237 1000309004i32 => f.write_str("PER_TILE_END_INFO"),
8238 1000309005i32 => f.write_str("DISPATCH_TILE_INFO"),
8239 1000310000i32 => f.write_str("QUERY_LOW_LATENCY_SUPPORT"),
8240 1000311000i32 => f.write_str("EXPORT_METAL_OBJECT_CREATE_INFO"),
8241 1000311001i32 => f.write_str("EXPORT_METAL_OBJECTS_INFO"),
8242 1000311002i32 => f.write_str("EXPORT_METAL_DEVICE_INFO"),
8243 1000311003i32 => f.write_str("EXPORT_METAL_COMMAND_QUEUE_INFO"),
8244 1000311004i32 => f.write_str("EXPORT_METAL_BUFFER_INFO"),
8245 1000311005i32 => f.write_str("IMPORT_METAL_BUFFER_INFO"),
8246 1000311006i32 => f.write_str("EXPORT_METAL_TEXTURE_INFO"),
8247 1000311007i32 => f.write_str("IMPORT_METAL_TEXTURE_INFO"),
8248 1000311008i32 => f.write_str("EXPORT_METAL_IO_SURFACE_INFO"),
8249 1000311009i32 => f.write_str("IMPORT_METAL_IO_SURFACE_INFO"),
8250 1000311010i32 => f.write_str("EXPORT_METAL_SHARED_EVENT_INFO"),
8251 1000311011i32 => f.write_str("IMPORT_METAL_SHARED_EVENT_INFO"),
8252 1000316000i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES"),
8253 1000316001i32 => {
8254 f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES")
8255 }
8256 1000316002i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES"),
8257 1000316003i32 => f.write_str("DESCRIPTOR_ADDRESS_INFO"),
8258 1000316004i32 => f.write_str("DESCRIPTOR_GET_INFO"),
8259 1000316005i32 => f.write_str("BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO"),
8260 1000316006i32 => f.write_str("IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO"),
8261 1000316007i32 => f.write_str("IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO"),
8262 1000316008i32 => f.write_str("SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO"),
8263 1000316010i32 => f.write_str("OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO"),
8264 1000316011i32 => f.write_str("DESCRIPTOR_BUFFER_BINDING_INFO"),
8265 1000316012i32 => {
8266 f.write_str("DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE")
8267 }
8268 1000316009i32 => {
8269 f.write_str("ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO")
8270 }
8271 1000318000i32 => f.write_str("DEVICE_MEMORY_COPY"),
8272 1000318001i32 => f.write_str("COPY_DEVICE_MEMORY_INFO"),
8273 1000318002i32 => f.write_str("DEVICE_MEMORY_IMAGE_COPY"),
8274 1000318003i32 => f.write_str("COPY_DEVICE_MEMORY_IMAGE_INFO"),
8275 1000318004i32 => f.write_str("MEMORY_RANGE_BARRIERS_INFO"),
8276 1000318005i32 => f.write_str("MEMORY_RANGE_BARRIER"),
8277 1000318006i32 => {
8278 f.write_str("PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES")
8279 }
8280 1000318007i32 => f.write_str("BIND_INDEX_BUFFER_3_INFO"),
8281 1000318008i32 => f.write_str("BIND_VERTEX_BUFFER_3_INFO"),
8282 1000318009i32 => f.write_str("DRAW_INDIRECT_2_INFO"),
8283 1000318010i32 => f.write_str("DRAW_INDIRECT_COUNT_2_INFO"),
8284 1000318011i32 => f.write_str("DISPATCH_INDIRECT_2_INFO"),
8285 1000318012i32 => f.write_str("CONDITIONAL_RENDERING_BEGIN_INFO_2"),
8286 1000318013i32 => f.write_str("BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO"),
8287 1000318014i32 => f.write_str("MEMORY_MARKER_INFO"),
8288 1000318015i32 => f.write_str("ACCELERATION_STRUCTURE_CREATE_INFO_2"),
8289 1000320000i32 => {
8290 f.write_str("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES")
8291 }
8292 1000320001i32 => {
8293 f.write_str("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES")
8294 }
8295 1000320002i32 => f.write_str("GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO"),
8296 1000321000i32 => {
8297 f.write_str(
8298 "PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES",
8299 )
8300 }
8301 1000322000i32 => {
8302 f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES")
8303 }
8304 1000323000i32 => {
8305 f.write_str(
8306 "PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES",
8307 )
8308 }
8309 1000326000i32 => {
8310 f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES")
8311 }
8312 1000326001i32 => {
8313 f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES")
8314 }
8315 1000326002i32 => {
8316 f.write_str("PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO")
8317 }
8318 1000327000i32 => {
8319 f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA")
8320 }
8321 1000327001i32 => {
8322 f.write_str("PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES")
8323 }
8324 1000327002i32 => f.write_str("ACCELERATION_STRUCTURE_MOTION_INFO"),
8325 1000330000i32 => {
8326 f.write_str("PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES")
8327 }
8328 1000332000i32 => {
8329 f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES")
8330 }
8331 1000332001i32 => {
8332 f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES")
8333 }
8334 1000333000i32 => f.write_str("COPY_COMMAND_TRANSFORM_INFO"),
8335 1000336000i32 => {
8336 f.write_str("PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES")
8337 }
8338 1000338000i32 => {
8339 f.write_str("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES")
8340 }
8341 1000338001i32 => f.write_str("IMAGE_COMPRESSION_CONTROL"),
8342 1000338004i32 => f.write_str("IMAGE_COMPRESSION_PROPERTIES"),
8343 1000339000i32 => {
8344 f.write_str("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES")
8345 }
8346 1000340000i32 => f.write_str("PHYSICAL_DEVICE_4444_FORMATS_FEATURES"),
8347 1000341000i32 => f.write_str("PHYSICAL_DEVICE_FAULT_FEATURES"),
8348 1000341001i32 => f.write_str("DEVICE_FAULT_COUNTS"),
8349 1000341002i32 => f.write_str("DEVICE_FAULT_INFO"),
8350 1000344000i32 => f.write_str("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES"),
8351 1000346000i32 => f.write_str("DIRECTFB_SURFACE_CREATE_INFO"),
8352 1000352000i32 => {
8353 f.write_str("PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES")
8354 }
8355 1000352001i32 => f.write_str("VERTEX_INPUT_BINDING_DESCRIPTION_2"),
8356 1000352002i32 => f.write_str("VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2"),
8357 1000353000i32 => f.write_str("PHYSICAL_DEVICE_DRM_PROPERTIES"),
8358 1000354000i32 => {
8359 f.write_str("PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES")
8360 }
8361 1000354001i32 => f.write_str("DEVICE_ADDRESS_BINDING_CALLBACK_DATA"),
8362 1000355000i32 => f.write_str("PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES"),
8363 1000355001i32 => {
8364 f.write_str("PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO")
8365 }
8366 1000356000i32 => {
8367 f.write_str("PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES")
8368 }
8369 1000364000i32 => f.write_str("IMPORT_MEMORY_ZIRCON_HANDLE_INFO"),
8370 1000364001i32 => f.write_str("MEMORY_ZIRCON_HANDLE_PROPERTIES"),
8371 1000364002i32 => f.write_str("MEMORY_GET_ZIRCON_HANDLE_INFO"),
8372 1000365000i32 => f.write_str("IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO"),
8373 1000365001i32 => f.write_str("SEMAPHORE_GET_ZIRCON_HANDLE_INFO"),
8374 1000366000i32 => f.write_str("BUFFER_COLLECTION_CREATE_INFO"),
8375 1000366001i32 => f.write_str("IMPORT_MEMORY_BUFFER_COLLECTION"),
8376 1000366002i32 => f.write_str("BUFFER_COLLECTION_IMAGE_CREATE_INFO"),
8377 1000366003i32 => f.write_str("BUFFER_COLLECTION_PROPERTIES"),
8378 1000366004i32 => f.write_str("BUFFER_CONSTRAINTS_INFO"),
8379 1000366005i32 => f.write_str("BUFFER_COLLECTION_BUFFER_CREATE_INFO"),
8380 1000366006i32 => f.write_str("IMAGE_CONSTRAINTS_INFO"),
8381 1000366007i32 => f.write_str("IMAGE_FORMAT_CONSTRAINTS_INFO"),
8382 1000366008i32 => f.write_str("SYSMEM_COLOR_SPACE"),
8383 1000366009i32 => f.write_str("BUFFER_COLLECTION_CONSTRAINTS_INFO"),
8384 1000369000i32 => f.write_str("SUBPASS_SHADING_PIPELINE_CREATE_INFO"),
8385 1000369001i32 => f.write_str("PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES"),
8386 1000369002i32 => f.write_str("PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES"),
8387 1000370000i32 => f.write_str("PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES"),
8388 1000371000i32 => f.write_str("MEMORY_GET_REMOTE_ADDRESS_INFO"),
8389 1000371001i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES"),
8390 1000372000i32 => f.write_str("PIPELINE_PROPERTIES_IDENTIFIER"),
8391 1000372001i32 => f.write_str("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES"),
8392 1000375000i32 => f.write_str("PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES"),
8393 1000375001i32 => f.write_str("FRAME_BOUNDARY"),
8394 1000376000i32 => {
8395 f.write_str(
8396 "PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES",
8397 )
8398 }
8399 1000376001i32 => f.write_str("SUBPASS_RESOLVE_PERFORMANCE_QUERY"),
8400 1000376002i32 => f.write_str("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO"),
8401 1000377000i32 => {
8402 f.write_str("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES")
8403 }
8404 1000378000i32 => f.write_str("SCREEN_SURFACE_CREATE_INFO"),
8405 1000381000i32 => f.write_str("PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES"),
8406 1000381001i32 => f.write_str("PIPELINE_COLOR_WRITE_CREATE_INFO"),
8407 1000382000i32 => {
8408 f.write_str("PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES")
8409 }
8410 1000386000i32 => {
8411 f.write_str("PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES")
8412 }
8413 1000387000i32 => {
8414 f.write_str("PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES")
8415 }
8416 1000390000i32 => {
8417 f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES")
8418 }
8419 1000390001i32 => f.write_str("VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES"),
8420 1000390002i32 => f.write_str("VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO"),
8421 1000390003i32 => {
8422 f.write_str("VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO")
8423 }
8424 1000391000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES"),
8425 1000391001i32 => f.write_str("IMAGE_VIEW_MIN_LOD_CREATE_INFO"),
8426 1000392000i32 => f.write_str("PHYSICAL_DEVICE_MULTI_DRAW_FEATURES"),
8427 1000392001i32 => f.write_str("PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES"),
8428 1000393000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES"),
8429 1000395000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES"),
8430 1000395001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES"),
8431 1000396000i32 => f.write_str("MICROMAP_BUILD_INFO"),
8432 1000396001i32 => f.write_str("MICROMAP_VERSION_INFO"),
8433 1000396002i32 => f.write_str("COPY_MICROMAP_INFO"),
8434 1000396003i32 => f.write_str("COPY_MICROMAP_TO_MEMORY_INFO"),
8435 1000396004i32 => f.write_str("COPY_MEMORY_TO_MICROMAP_INFO"),
8436 1000396005i32 => f.write_str("PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES"),
8437 1000396006i32 => f.write_str("PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES"),
8438 1000396007i32 => f.write_str("MICROMAP_CREATE_INFO"),
8439 1000396008i32 => f.write_str("MICROMAP_BUILD_SIZES_INFO"),
8440 1000396009i32 => {
8441 f.write_str("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP")
8442 }
8443 1000397000i32 => {
8444 f.write_str("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES")
8445 }
8446 1000397001i32 => {
8447 f.write_str("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES")
8448 }
8449 1000397002i32 => {
8450 f.write_str("ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP")
8451 }
8452 1000404000i32 => {
8453 f.write_str("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES")
8454 }
8455 1000404001i32 => {
8456 f.write_str("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES")
8457 }
8458 1000404002i32 => {
8459 f.write_str("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES")
8460 }
8461 1000411000i32 => f.write_str("PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES"),
8462 1000411001i32 => {
8463 f.write_str("SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO")
8464 }
8465 1000412000i32 => {
8466 f.write_str("PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES")
8467 }
8468 1000417000i32 => f.write_str("DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO"),
8469 1000417001i32 => f.write_str("PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES"),
8470 1000417002i32 => {
8471 f.write_str("PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES")
8472 }
8473 1000418000i32 => {
8474 f.write_str("PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES")
8475 }
8476 1000418001i32 => f.write_str("IMAGE_VIEW_SLICED_CREATE_INFO"),
8477 1000420000i32 => {
8478 f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES")
8479 }
8480 1000420001i32 => f.write_str("DESCRIPTOR_SET_BINDING_REFERENCE"),
8481 1000420002i32 => f.write_str("DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO"),
8482 1000422000i32 => {
8483 f.write_str("PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES")
8484 }
8485 1000424000i32 => f.write_str("PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES"),
8486 1000424001i32 => {
8487 f.write_str("PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES")
8488 }
8489 1000424002i32 => f.write_str("RENDER_PASS_STRIPE_BEGIN_INFO"),
8490 1000424003i32 => f.write_str("RENDER_PASS_STRIPE_INFO"),
8491 1000424004i32 => f.write_str("RENDER_PASS_STRIPE_SUBMIT_INFO"),
8492 1000426000i32 => f.write_str("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES"),
8493 1000428000i32 => {
8494 f.write_str("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES")
8495 }
8496 1000428001i32 => f.write_str("COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO"),
8497 1000428002i32 => f.write_str("PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO"),
8498 1000429008i32 => {
8499 f.write_str("PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES")
8500 }
8501 1000429009i32 => {
8502 f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA")
8503 }
8504 1000429010i32 => f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA"),
8505 1000430000i32 => {
8506 f.write_str("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES")
8507 }
8508 1000434000i32 => {
8509 f.write_str("PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES")
8510 }
8511 1000437000i32 => {
8512 f.write_str(
8513 "PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES",
8514 )
8515 }
8516 1000440000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES"),
8517 1000440001i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES"),
8518 1000440002i32 => f.write_str("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO"),
8519 1000451000i32 => {
8520 f.write_str("PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES")
8521 }
8522 1000451001i32 => {
8523 f.write_str("PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES")
8524 }
8525 1000452000i32 => f.write_str("NATIVE_BUFFER_USAGE"),
8526 1000452001i32 => f.write_str("NATIVE_BUFFER_PROPERTIES"),
8527 1000452002i32 => f.write_str("NATIVE_BUFFER_FORMAT_PROPERTIES"),
8528 1000452003i32 => f.write_str("IMPORT_NATIVE_BUFFER_INFO"),
8529 1000452004i32 => f.write_str("MEMORY_GET_NATIVE_BUFFER_INFO"),
8530 1000453000i32 => f.write_str("EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED"),
8531 1000455000i32 => {
8532 f.write_str("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES")
8533 }
8534 1000455001i32 => {
8535 f.write_str("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES")
8536 }
8537 1000458000i32 => {
8538 f.write_str("PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES")
8539 }
8540 1000458001i32 => f.write_str("RENDER_PASS_CREATION_CONTROL"),
8541 1000458002i32 => f.write_str("RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO"),
8542 1000458003i32 => f.write_str("RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO"),
8543 1000459000i32 => f.write_str("DIRECT_DRIVER_LOADING_INFO"),
8544 1000459001i32 => f.write_str("DIRECT_DRIVER_LOADING_LIST"),
8545 1000460000i32 => f.write_str("TENSOR_CREATE_INFO"),
8546 1000460001i32 => f.write_str("TENSOR_VIEW_CREATE_INFO"),
8547 1000460002i32 => f.write_str("BIND_TENSOR_MEMORY_INFO"),
8548 1000460003i32 => f.write_str("WRITE_DESCRIPTOR_SET_TENSOR"),
8549 1000460004i32 => f.write_str("PHYSICAL_DEVICE_TENSOR_PROPERTIES"),
8550 1000460005i32 => f.write_str("TENSOR_FORMAT_PROPERTIES"),
8551 1000460006i32 => f.write_str("TENSOR_DESCRIPTION"),
8552 1000460007i32 => f.write_str("TENSOR_MEMORY_REQUIREMENTS_INFO"),
8553 1000460008i32 => f.write_str("TENSOR_MEMORY_BARRIER"),
8554 1000460009i32 => f.write_str("PHYSICAL_DEVICE_TENSOR_FEATURES"),
8555 1000460010i32 => f.write_str("DEVICE_TENSOR_MEMORY_REQUIREMENTS"),
8556 1000460011i32 => f.write_str("COPY_TENSOR_INFO"),
8557 1000460012i32 => f.write_str("TENSOR_COPY"),
8558 1000460013i32 => f.write_str("TENSOR_DEPENDENCY_INFO"),
8559 1000460014i32 => f.write_str("MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR"),
8560 1000460015i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO"),
8561 1000460016i32 => f.write_str("EXTERNAL_TENSOR_PROPERTIES"),
8562 1000460017i32 => f.write_str("EXTERNAL_MEMORY_TENSOR_CREATE_INFO"),
8563 1000460018i32 => {
8564 f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES")
8565 }
8566 1000460019i32 => {
8567 f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES")
8568 }
8569 1000460020i32 => f.write_str("DESCRIPTOR_GET_TENSOR_INFO"),
8570 1000460021i32 => f.write_str("TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO"),
8571 1000460022i32 => f.write_str("TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO"),
8572 1000460023i32 => f.write_str("FRAME_BOUNDARY_TENSORS"),
8573 1000462000i32 => {
8574 f.write_str("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES")
8575 }
8576 1000462001i32 => {
8577 f.write_str("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES")
8578 }
8579 1000462002i32 => {
8580 f.write_str("PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO")
8581 }
8582 1000462003i32 => f.write_str("SHADER_MODULE_IDENTIFIER"),
8583 1000464000i32 => f.write_str("PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES"),
8584 1000464001i32 => f.write_str("PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES"),
8585 1000464002i32 => f.write_str("OPTICAL_FLOW_IMAGE_FORMAT_INFO"),
8586 1000464003i32 => f.write_str("OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES"),
8587 1000464004i32 => f.write_str("OPTICAL_FLOW_SESSION_CREATE_INFO"),
8588 1000464005i32 => f.write_str("OPTICAL_FLOW_EXECUTE_INFO"),
8589 1000464010i32 => f.write_str("OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO"),
8590 1000465000i32 => f.write_str("PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES"),
8591 1000468000i32 => {
8592 f.write_str("PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES")
8593 }
8594 1000468001i32 => {
8595 f.write_str("PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES")
8596 }
8597 1000468002i32 => {
8598 f.write_str("ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES")
8599 }
8600 1000476000i32 => f.write_str("PHYSICAL_DEVICE_ANTI_LAG_FEATURES"),
8601 1000476001i32 => f.write_str("ANTI_LAG_DATA"),
8602 1000476002i32 => f.write_str("ANTI_LAG_PRESENTATION_INFO"),
8603 1000478000i32 => {
8604 f.write_str("PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES")
8605 }
8606 1000478001i32 => {
8607 f.write_str(
8608 "ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA",
8609 )
8610 }
8611 1000479000i32 => f.write_str("SURFACE_CAPABILITIES_PRESENT_ID_2"),
8612 1000479001i32 => f.write_str("PRESENT_ID_2"),
8613 1000479002i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES"),
8614 1000480000i32 => f.write_str("SURFACE_CAPABILITIES_PRESENT_WAIT_2"),
8615 1000480001i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES"),
8616 1000480002i32 => f.write_str("PRESENT_WAIT_2_INFO"),
8617 1000481000i32 => {
8618 f.write_str("PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES")
8619 }
8620 1000482000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES"),
8621 1000482001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES"),
8622 1000482002i32 => f.write_str("SHADER_CREATE_INFO"),
8623 1000483000i32 => f.write_str("PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES"),
8624 1000483001i32 => f.write_str("PIPELINE_BINARY_CREATE_INFO"),
8625 1000483002i32 => f.write_str("PIPELINE_BINARY_INFO"),
8626 1000483003i32 => f.write_str("PIPELINE_BINARY_KEY"),
8627 1000483004i32 => f.write_str("PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES"),
8628 1000483005i32 => f.write_str("RELEASE_CAPTURED_PIPELINE_DATA_INFO"),
8629 1000483006i32 => f.write_str("PIPELINE_BINARY_DATA_INFO"),
8630 1000483007i32 => f.write_str("PIPELINE_CREATE_INFO"),
8631 1000483008i32 => f.write_str("DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL"),
8632 1000483009i32 => f.write_str("PIPELINE_BINARY_HANDLES_INFO"),
8633 1000484000i32 => f.write_str("PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES"),
8634 1000484001i32 => f.write_str("TILE_PROPERTIES"),
8635 1000485000i32 => f.write_str("PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES"),
8636 1000485001i32 => f.write_str("AMIGO_PROFILING_SUBMIT_INFO"),
8637 1000488000i32 => {
8638 f.write_str("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES")
8639 }
8640 1000490000i32 => {
8641 f.write_str("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES")
8642 }
8643 1000490001i32 => {
8644 f.write_str("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES")
8645 }
8646 1000491000i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES"),
8647 1000491001i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES"),
8648 1000491002i32 => f.write_str("COOPERATIVE_VECTOR_PROPERTIES"),
8649 1000491004i32 => f.write_str("CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO"),
8650 1000492000i32 => {
8651 f.write_str("PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES")
8652 }
8653 1000492001i32 => {
8654 f.write_str("PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES")
8655 }
8656 1000495000i32 => {
8657 f.write_str("PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES")
8658 }
8659 1000495001i32 => {
8660 f.write_str("PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES")
8661 }
8662 1000496000i32 => f.write_str("LAYER_SETTINGS_CREATE_INFO"),
8663 1000497000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES"),
8664 1000497001i32 => {
8665 f.write_str("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES")
8666 }
8667 1000498000i32 => {
8668 f.write_str("PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES")
8669 }
8670 1000499000i32 => {
8671 f.write_str(
8672 "PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES",
8673 )
8674 }
8675 1000504000i32 => {
8676 f.write_str("PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES")
8677 }
8678 1000505000i32 => f.write_str("LATENCY_SLEEP_MODE_INFO"),
8679 1000505001i32 => f.write_str("LATENCY_SLEEP_INFO"),
8680 1000505002i32 => f.write_str("SET_LATENCY_MARKER_INFO"),
8681 1000505003i32 => f.write_str("GET_LATENCY_MARKER_INFO"),
8682 1000505004i32 => f.write_str("LATENCY_TIMINGS_FRAME_REPORT"),
8683 1000505005i32 => f.write_str("LATENCY_SUBMISSION_PRESENT_ID"),
8684 1000505006i32 => f.write_str("OUT_OF_BAND_QUEUE_TYPE_INFO"),
8685 1000505007i32 => f.write_str("SWAPCHAIN_LATENCY_CREATE_INFO"),
8686 1000505008i32 => f.write_str("LATENCY_SURFACE_CAPABILITIES"),
8687 1000507000i32 => f.write_str("DATA_GRAPH_PIPELINE_CREATE_INFO"),
8688 1000507001i32 => f.write_str("DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO"),
8689 1000507002i32 => f.write_str("DATA_GRAPH_PIPELINE_RESOURCE_INFO"),
8690 1000507003i32 => f.write_str("DATA_GRAPH_PIPELINE_CONSTANT"),
8691 1000507004i32 => {
8692 f.write_str("DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO")
8693 }
8694 1000507005i32 => f.write_str("BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO"),
8695 1000507006i32 => f.write_str("PHYSICAL_DEVICE_DATA_GRAPH_FEATURES"),
8696 1000507007i32 => f.write_str("DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO"),
8697 1000507008i32 => f.write_str("DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT"),
8698 1000507009i32 => f.write_str("DATA_GRAPH_PIPELINE_INFO"),
8699 1000507010i32 => {
8700 f.write_str("DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO")
8701 }
8702 1000507011i32 => {
8703 f.write_str("DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO")
8704 }
8705 1000507012i32 => {
8706 f.write_str("DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT")
8707 }
8708 1000507013i32 => f.write_str("DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO"),
8709 1000507014i32 => f.write_str("DATA_GRAPH_PIPELINE_DISPATCH_INFO"),
8710 1000507016i32 => f.write_str("DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO"),
8711 1000507017i32 => {
8712 f.write_str("QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES")
8713 }
8714 1000507018i32 => f.write_str("QUEUE_FAMILY_DATA_GRAPH_PROPERTIES"),
8715 1000507019i32 => {
8716 f.write_str(
8717 "PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO",
8718 )
8719 }
8720 1000507015i32 => {
8721 f.write_str(
8722 "DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO",
8723 )
8724 }
8725 1000510000i32 => {
8726 f.write_str("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES")
8727 }
8728 1000510001i32 => {
8729 f.write_str("MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO")
8730 }
8731 1000511000i32 => {
8732 f.write_str("PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES")
8733 }
8734 1000512000i32 => f.write_str("VIDEO_DECODE_AV1_CAPABILITIES"),
8735 1000512001i32 => f.write_str("VIDEO_DECODE_AV1_PICTURE_INFO"),
8736 1000512003i32 => f.write_str("VIDEO_DECODE_AV1_PROFILE_INFO"),
8737 1000512004i32 => {
8738 f.write_str("VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO")
8739 }
8740 1000512005i32 => f.write_str("VIDEO_DECODE_AV1_DPB_SLOT_INFO"),
8741 1000513000i32 => f.write_str("VIDEO_ENCODE_AV1_CAPABILITIES"),
8742 1000513001i32 => {
8743 f.write_str("VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO")
8744 }
8745 1000513002i32 => f.write_str("VIDEO_ENCODE_AV1_PICTURE_INFO"),
8746 1000513003i32 => f.write_str("VIDEO_ENCODE_AV1_DPB_SLOT_INFO"),
8747 1000513004i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES"),
8748 1000513005i32 => f.write_str("VIDEO_ENCODE_AV1_PROFILE_INFO"),
8749 1000513006i32 => f.write_str("VIDEO_ENCODE_AV1_RATE_CONTROL_INFO"),
8750 1000513007i32 => f.write_str("VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO"),
8751 1000513008i32 => f.write_str("VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES"),
8752 1000513009i32 => f.write_str("VIDEO_ENCODE_AV1_SESSION_CREATE_INFO"),
8753 1000513010i32 => f.write_str("VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO"),
8754 1000514000i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES"),
8755 1000514001i32 => f.write_str("VIDEO_DECODE_VP9_CAPABILITIES"),
8756 1000514002i32 => f.write_str("VIDEO_DECODE_VP9_PICTURE_INFO"),
8757 1000514003i32 => f.write_str("VIDEO_DECODE_VP9_PROFILE_INFO"),
8758 1000515000i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES"),
8759 1000515001i32 => f.write_str("VIDEO_INLINE_QUERY_INFO"),
8760 1000516000i32 => {
8761 f.write_str("PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES")
8762 }
8763 1000518000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES"),
8764 1000518001i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES"),
8765 1000518002i32 => f.write_str("SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO"),
8766 1000519000i32 => f.write_str("SAMPLER_CUBIC_WEIGHTS_CREATE_INFO"),
8767 1000519001i32 => f.write_str("PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES"),
8768 1000519002i32 => f.write_str("BLIT_IMAGE_CUBIC_WEIGHTS_INFO"),
8769 1000520000i32 => f.write_str("PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES"),
8770 1000520001i32 => {
8771 f.write_str("SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO")
8772 }
8773 1000521000i32 => f.write_str("PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES"),
8774 1000524000i32 => {
8775 f.write_str(
8776 "PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES",
8777 )
8778 }
8779 1000527000i32 => {
8780 f.write_str("PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES")
8781 }
8782 1000527001i32 => f.write_str("ATTACHMENT_FEEDBACK_LOOP_INFO"),
8783 1000529000i32 => f.write_str("SCREEN_BUFFER_PROPERTIES"),
8784 1000529001i32 => f.write_str("SCREEN_BUFFER_FORMAT_PROPERTIES"),
8785 1000529002i32 => f.write_str("IMPORT_SCREEN_BUFFER_INFO"),
8786 1000529004i32 => {
8787 f.write_str("PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES")
8788 }
8789 1000530000i32 => f.write_str("PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES"),
8790 1000545007i32 => f.write_str("SET_DESCRIPTOR_BUFFER_OFFSETS_INFO"),
8791 1000545008i32 => f.write_str("BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO"),
8792 1000546000i32 => {
8793 f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES")
8794 }
8795 1000547000i32 => f.write_str("PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES"),
8796 1000547001i32 => f.write_str("PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES"),
8797 1000547002i32 => f.write_str("TILE_MEMORY_REQUIREMENTS"),
8798 1000547003i32 => f.write_str("TILE_MEMORY_BIND_INFO"),
8799 1000547004i32 => f.write_str("TILE_MEMORY_SIZE_INFO"),
8800 1000549002i32 => f.write_str("COPY_MEMORY_INDIRECT_INFO"),
8801 1000549003i32 => f.write_str("COPY_MEMORY_TO_IMAGE_INDIRECT_INFO"),
8802 1000550002i32 => f.write_str("DECOMPRESS_MEMORY_INFO"),
8803 1000551000i32 => f.write_str("DISPLAY_SURFACE_STEREO_CREATE_INFO"),
8804 1000551001i32 => f.write_str("DISPLAY_MODE_STEREO_PROPERTIES"),
8805 1000552000i32 => f.write_str("VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES"),
8806 1000552001i32 => {
8807 f.write_str("VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO")
8808 }
8809 1000552002i32 => f.write_str("VIDEO_ENCODE_INTRA_REFRESH_INFO"),
8810 1000552003i32 => f.write_str("VIDEO_REFERENCE_INTRA_REFRESH_INFO"),
8811 1000552004i32 => {
8812 f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES")
8813 }
8814 1000553000i32 => f.write_str("VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES"),
8815 1000553001i32 => f.write_str("VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES"),
8816 1000553002i32 => f.write_str("VIDEO_ENCODE_QUANTIZATION_MAP_INFO"),
8817 1000553005i32 => {
8818 f.write_str(
8819 "VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO",
8820 )
8821 }
8822 1000553009i32 => {
8823 f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES")
8824 }
8825 1000553003i32 => {
8826 f.write_str("VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES")
8827 }
8828 1000553004i32 => {
8829 f.write_str("VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES")
8830 }
8831 1000553006i32 => f.write_str("VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES"),
8832 1000553007i32 => {
8833 f.write_str("VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES")
8834 }
8835 1000553008i32 => f.write_str("VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES"),
8836 1000555000i32 => f.write_str("PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES"),
8837 1000556000i32 => f.write_str("EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO"),
8838 1000556001i32 => f.write_str("EXTERNAL_COMPUTE_QUEUE_CREATE_INFO"),
8839 1000556002i32 => f.write_str("EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS"),
8840 1000556003i32 => {
8841 f.write_str("PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES")
8842 }
8843 1000558000i32 => {
8844 f.write_str(
8845 "PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES",
8846 )
8847 }
8848 1000559000i32 => {
8849 f.write_str("PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES")
8850 }
8851 1000562000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES"),
8852 1000562001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES"),
8853 1000562002i32 => f.write_str("PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST"),
8854 1000562003i32 => f.write_str("PHYSICAL_DEVICE_LAYERED_API_PROPERTIES"),
8855 1000562004i32 => f.write_str("PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES"),
8856 1000563000i32 => {
8857 f.write_str("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES")
8858 }
8859 1000564000i32 => {
8860 f.write_str("PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES")
8861 }
8862 1000567000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES"),
8863 1000568000i32 => {
8864 f.write_str("PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES")
8865 }
8866 1000569000i32 => {
8867 f.write_str("PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES")
8868 }
8869 1000569001i32 => {
8870 f.write_str("PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES")
8871 }
8872 1000569002i32 => {
8873 f.write_str("CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT")
8874 }
8875 1000569003i32 => {
8876 f.write_str("CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT")
8877 }
8878 1000569004i32 => {
8879 f.write_str("CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT")
8880 }
8881 1000569005i32 => f.write_str("CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO"),
8882 1000569006i32 => f.write_str("CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO"),
8883 1000569007i32 => {
8884 f.write_str(
8885 "RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO",
8886 )
8887 }
8888 1000570000i32 => {
8889 f.write_str(
8890 "PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES",
8891 )
8892 }
8893 1000570001i32 => {
8894 f.write_str(
8895 "PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES",
8896 )
8897 }
8898 1000570002i32 => {
8899 f.write_str("WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE")
8900 }
8901 1000570003i32 => {
8902 f.write_str("PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT")
8903 }
8904 1000570004i32 => f.write_str("BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO"),
8905 1000570005i32 => f.write_str("PARTITIONED_ACCELERATION_STRUCTURE_FLAGS"),
8906 1000572003i32 => f.write_str("INDIRECT_EXECUTION_SET_CREATE_INFO"),
8907 1000572008i32 => f.write_str("WRITE_INDIRECT_EXECUTION_SET_PIPELINE"),
8908 1000572009i32 => f.write_str("WRITE_INDIRECT_EXECUTION_SET_SHADER"),
8909 1000572010i32 => f.write_str("INDIRECT_EXECUTION_SET_PIPELINE_INFO"),
8910 1000572011i32 => f.write_str("INDIRECT_EXECUTION_SET_SHADER_INFO"),
8911 1000572012i32 => f.write_str("INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO"),
8912 1000572013i32 => f.write_str("GENERATED_COMMANDS_PIPELINE_INFO"),
8913 1000572014i32 => f.write_str("GENERATED_COMMANDS_SHADER_INFO"),
8914 1000573001i32 => f.write_str("PHYSICAL_DEVICE_FAULT_PROPERTIES"),
8915 1000573003i32 => f.write_str("DEVICE_FAULT_DEBUG_INFO"),
8916 1000574000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES"),
8917 1000574002i32 => f.write_str("MEMORY_BARRIER_ACCESS_FLAGS_3"),
8918 1000575000i32 => {
8919 f.write_str("PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES")
8920 }
8921 1000575001i32 => {
8922 f.write_str("PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES")
8923 }
8924 1000575002i32 => f.write_str("IMAGE_ALIGNMENT_CONTROL_CREATE_INFO"),
8925 1000579000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_FMA_FEATURES"),
8926 1000580000i32 => f.write_str("PUSH_CONSTANT_BANK_INFO"),
8927 1000580001i32 => f.write_str("PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES"),
8928 1000580002i32 => f.write_str("PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES"),
8929 1000582000i32 => f.write_str("PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES"),
8930 1000582001i32 => {
8931 f.write_str("PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO")
8932 }
8933 1000584000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES"),
8934 1000584001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES"),
8935 1000584002i32 => f.write_str("QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES"),
8936 1000586000i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES"),
8937 1000586001i32 => {
8938 f.write_str("VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO")
8939 }
8940 1000586002i32 => {
8941 f.write_str("VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO")
8942 }
8943 1000586003i32 => {
8944 f.write_str("VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO")
8945 }
8946 1000685000i32 => f.write_str("SURFACE_CREATE_INFO"),
8947 1000590000i32 => f.write_str("PHYSICAL_DEVICE_HDR_VIVID_FEATURES"),
8948 1000590001i32 => f.write_str("HDR_VIVID_DYNAMIC_METADATA"),
8949 1000593000i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES"),
8950 1000593001i32 => {
8951 f.write_str("COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES")
8952 }
8953 1000593002i32 => {
8954 f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES")
8955 }
8956 1000596000i32 => {
8957 f.write_str("PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES")
8958 }
8959 1000602000i32 => f.write_str("IMPORT_MEMORY_METAL_HANDLE_INFO"),
8960 1000602001i32 => f.write_str("MEMORY_METAL_HANDLE_PROPERTIES"),
8961 1000602002i32 => f.write_str("MEMORY_GET_METAL_HANDLE_INFO"),
8962 1000605000i32 => {
8963 f.write_str("PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES")
8964 }
8965 1000605001i32 => {
8966 f.write_str("PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES")
8967 }
8968 1000605004i32 => {
8969 f.write_str("RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO")
8970 }
8971 1000607000i32 => {
8972 f.write_str("PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES")
8973 }
8974 1000607001i32 => {
8975 f.write_str("PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES")
8976 }
8977 1000607002i32 => f.write_str("SHADER_INSTRUMENTATION_CREATE_INFO"),
8978 1000607003i32 => f.write_str("SHADER_INSTRUMENTATION_METRIC_DESCRIPTION"),
8979 1000608000i32 => {
8980 f.write_str("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES")
8981 }
8982 1000609000i32 => f.write_str("PHYSICAL_DEVICE_FORMAT_PACK_FEATURES"),
8983 1000611000i32 => {
8984 f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES")
8985 }
8986 1000611001i32 => {
8987 f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES")
8988 }
8989 1000611002i32 => {
8990 f.write_str("PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO")
8991 }
8992 1000613000i32 => f.write_str("SET_PRESENT_CONFIG"),
8993 1000613001i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_METERING_FEATURES"),
8994 1000425002i32 => {
8995 f.write_str("RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO")
8996 }
8997 1000620000i32 => {
8998 f.write_str("PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES")
8999 }
9000 1000627000i32 => {
9001 f.write_str("PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES")
9002 }
9003 1000628000i32 => f.write_str("PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES"),
9004 1000628001i32 => f.write_str("BEGIN_CUSTOM_RESOLVE_INFO"),
9005 1000628002i32 => f.write_str("CUSTOM_RESOLVE_CREATE_INFO"),
9006 1000629000i32 => f.write_str("PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES"),
9007 1000629001i32 => f.write_str("DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO"),
9008 1000630000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES"),
9009 1000630001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES"),
9010 1000630002i32 => f.write_str("RENDERING_ATTACHMENT_FLAGS_INFO"),
9011 1000630004i32 => f.write_str("RESOLVE_IMAGE_MODE_INFO"),
9012 1000635000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES"),
9013 1000635001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES"),
9014 1000637000i32 => {
9015 f.write_str("PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES")
9016 }
9017 1000642000i32 => {
9018 f.write_str(
9019 "PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES",
9020 )
9021 }
9022 1000645000i32 => f.write_str("COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS"),
9023 1000645001i32 => {
9024 f.write_str("PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES")
9025 }
9026 1000662000i32 => {
9027 f.write_str("PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES")
9028 }
9029 1000664000i32 => f.write_str("UBM_SURFACE_CREATE_INFO"),
9030 1000673000i32 => {
9031 f.write_str("PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES")
9032 }
9033 other => write!(f, "{}({})", stringify!(StructureType), other),
9034 }
9035 }
9036}
9037#[repr(transparent)]
9039#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9040#[doc(alias = "VkSubpassContents")]
9041pub struct SubpassContents(i32);
9042impl SubpassContents {
9043 pub const INLINE: Self = Self(0i32);
9044 pub const SECONDARY_COMMAND_BUFFERS: Self = Self(1i32);
9045 #[inline]
9046 pub const fn from_raw(value: i32) -> Self {
9047 Self(value)
9048 }
9049 #[inline]
9050 pub const fn as_raw(self) -> i32 {
9051 self.0
9052 }
9053}
9054impl core::fmt::Debug for SubpassContents {
9055 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9056 match self.0 {
9057 0i32 => f.write_str("INLINE"),
9058 1i32 => f.write_str("SECONDARY_COMMAND_BUFFERS"),
9059 other => write!(f, "{}({})", stringify!(SubpassContents), other),
9060 }
9061 }
9062}
9063#[repr(transparent)]
9065#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9066#[doc(alias = "VkSubpassMergeStatusEXT")]
9067pub struct SubpassMergeStatusEXT(i32);
9068impl SubpassMergeStatusEXT {
9069 pub const MERGED: Self = Self(0i32);
9070 pub const DISALLOWED: Self = Self(1i32);
9071 pub const NOT_MERGED_SIDE_EFFECTS: Self = Self(2i32);
9072 pub const NOT_MERGED_SAMPLES_MISMATCH: Self = Self(3i32);
9073 pub const NOT_MERGED_VIEWS_MISMATCH: Self = Self(4i32);
9074 pub const NOT_MERGED_ALIASING: Self = Self(5i32);
9075 pub const NOT_MERGED_DEPENDENCIES: Self = Self(6i32);
9076 pub const NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT: Self = Self(7i32);
9077 pub const NOT_MERGED_TOO_MANY_ATTACHMENTS: Self = Self(8i32);
9078 pub const NOT_MERGED_INSUFFICIENT_STORAGE: Self = Self(9i32);
9079 pub const NOT_MERGED_DEPTH_STENCIL_COUNT: Self = Self(10i32);
9080 pub const NOT_MERGED_RESOLVE_ATTACHMENT_REUSE: Self = Self(11i32);
9081 pub const NOT_MERGED_SINGLE_SUBPASS: Self = Self(12i32);
9082 pub const NOT_MERGED_UNSPECIFIED: Self = Self(13i32);
9083 #[inline]
9084 pub const fn from_raw(value: i32) -> Self {
9085 Self(value)
9086 }
9087 #[inline]
9088 pub const fn as_raw(self) -> i32 {
9089 self.0
9090 }
9091}
9092impl core::fmt::Debug for SubpassMergeStatusEXT {
9093 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9094 match self.0 {
9095 0i32 => f.write_str("MERGED"),
9096 1i32 => f.write_str("DISALLOWED"),
9097 2i32 => f.write_str("NOT_MERGED_SIDE_EFFECTS"),
9098 3i32 => f.write_str("NOT_MERGED_SAMPLES_MISMATCH"),
9099 4i32 => f.write_str("NOT_MERGED_VIEWS_MISMATCH"),
9100 5i32 => f.write_str("NOT_MERGED_ALIASING"),
9101 6i32 => f.write_str("NOT_MERGED_DEPENDENCIES"),
9102 7i32 => f.write_str("NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT"),
9103 8i32 => f.write_str("NOT_MERGED_TOO_MANY_ATTACHMENTS"),
9104 9i32 => f.write_str("NOT_MERGED_INSUFFICIENT_STORAGE"),
9105 10i32 => f.write_str("NOT_MERGED_DEPTH_STENCIL_COUNT"),
9106 11i32 => f.write_str("NOT_MERGED_RESOLVE_ATTACHMENT_REUSE"),
9107 12i32 => f.write_str("NOT_MERGED_SINGLE_SUBPASS"),
9108 13i32 => f.write_str("NOT_MERGED_UNSPECIFIED"),
9109 other => write!(f, "{}({})", stringify!(SubpassMergeStatusEXT), other),
9110 }
9111 }
9112}
9113#[repr(transparent)]
9115#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9116#[doc(alias = "VkSystemAllocationScope")]
9117pub struct SystemAllocationScope(i32);
9118impl SystemAllocationScope {
9119 pub const COMMAND: Self = Self(0i32);
9120 pub const OBJECT: Self = Self(1i32);
9121 pub const CACHE: Self = Self(2i32);
9122 pub const DEVICE: Self = Self(3i32);
9123 pub const INSTANCE: Self = Self(4i32);
9124 #[inline]
9125 pub const fn from_raw(value: i32) -> Self {
9126 Self(value)
9127 }
9128 #[inline]
9129 pub const fn as_raw(self) -> i32 {
9130 self.0
9131 }
9132}
9133impl core::fmt::Debug for SystemAllocationScope {
9134 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9135 match self.0 {
9136 0i32 => f.write_str("COMMAND"),
9137 1i32 => f.write_str("OBJECT"),
9138 2i32 => f.write_str("CACHE"),
9139 3i32 => f.write_str("DEVICE"),
9140 4i32 => f.write_str("INSTANCE"),
9141 other => write!(f, "{}({})", stringify!(SystemAllocationScope), other),
9142 }
9143 }
9144}
9145#[repr(transparent)]
9147#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9148#[doc(alias = "VkTensorTilingARM")]
9149pub struct TensorTilingARM(i32);
9150impl TensorTilingARM {
9151 pub const OPTIMAL: Self = Self(0i32);
9152 pub const LINEAR: Self = Self(1i32);
9153 #[inline]
9154 pub const fn from_raw(value: i32) -> Self {
9155 Self(value)
9156 }
9157 #[inline]
9158 pub const fn as_raw(self) -> i32 {
9159 self.0
9160 }
9161}
9162impl core::fmt::Debug for TensorTilingARM {
9163 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9164 match self.0 {
9165 0i32 => f.write_str("OPTIMAL"),
9166 1i32 => f.write_str("LINEAR"),
9167 other => write!(f, "{}({})", stringify!(TensorTilingARM), other),
9168 }
9169 }
9170}
9171#[repr(transparent)]
9173#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9174#[doc(alias = "VkTessellationDomainOrigin")]
9175pub struct TessellationDomainOrigin(i32);
9176impl TessellationDomainOrigin {
9177 pub const UPPER_LEFT: Self = Self(0i32);
9178 pub const LOWER_LEFT: Self = Self(1i32);
9179 #[inline]
9180 pub const fn from_raw(value: i32) -> Self {
9181 Self(value)
9182 }
9183 #[inline]
9184 pub const fn as_raw(self) -> i32 {
9185 self.0
9186 }
9187}
9188impl core::fmt::Debug for TessellationDomainOrigin {
9189 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9190 match self.0 {
9191 0i32 => f.write_str("UPPER_LEFT"),
9192 1i32 => f.write_str("LOWER_LEFT"),
9193 other => write!(f, "{}({})", stringify!(TessellationDomainOrigin), other),
9194 }
9195 }
9196}
9197#[repr(transparent)]
9199#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9200#[doc(alias = "VkTimeDomainKHR")]
9201pub struct TimeDomainKHR(i32);
9202impl TimeDomainKHR {
9203 pub const DEVICE: Self = Self(0i32);
9204 pub const CLOCK_MONOTONIC: Self = Self(1i32);
9205 pub const CLOCK_MONOTONIC_RAW: Self = Self(2i32);
9206 pub const QUERY_PERFORMANCE_COUNTER: Self = Self(3i32);
9207 pub const PRESENT_STAGE_LOCAL: Self = Self(1000208000i32);
9208 pub const SWAPCHAIN_LOCAL: Self = Self(1000208001i32);
9209 #[inline]
9210 pub const fn from_raw(value: i32) -> Self {
9211 Self(value)
9212 }
9213 #[inline]
9214 pub const fn as_raw(self) -> i32 {
9215 self.0
9216 }
9217}
9218impl core::fmt::Debug for TimeDomainKHR {
9219 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9220 match self.0 {
9221 0i32 => f.write_str("DEVICE"),
9222 1i32 => f.write_str("CLOCK_MONOTONIC"),
9223 2i32 => f.write_str("CLOCK_MONOTONIC_RAW"),
9224 3i32 => f.write_str("QUERY_PERFORMANCE_COUNTER"),
9225 1000208000i32 => f.write_str("PRESENT_STAGE_LOCAL"),
9226 1000208001i32 => f.write_str("SWAPCHAIN_LOCAL"),
9227 other => write!(f, "{}({})", stringify!(TimeDomainKHR), other),
9228 }
9229 }
9230}
9231#[repr(transparent)]
9233#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9234#[doc(alias = "VkValidationCacheHeaderVersionEXT")]
9235pub struct ValidationCacheHeaderVersionEXT(i32);
9236impl ValidationCacheHeaderVersionEXT {
9237 pub const ONE: Self = Self(1i32);
9238 #[inline]
9239 pub const fn from_raw(value: i32) -> Self {
9240 Self(value)
9241 }
9242 #[inline]
9243 pub const fn as_raw(self) -> i32 {
9244 self.0
9245 }
9246}
9247impl core::fmt::Debug for ValidationCacheHeaderVersionEXT {
9248 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9249 match self.0 {
9250 1i32 => f.write_str("ONE"),
9251 other => {
9252 write!(f, "{}({})", stringify!(ValidationCacheHeaderVersionEXT), other)
9253 }
9254 }
9255 }
9256}
9257#[repr(transparent)]
9259#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9260#[doc(alias = "VkValidationCheckEXT")]
9261pub struct ValidationCheckEXT(i32);
9262impl ValidationCheckEXT {
9263 pub const ALL: Self = Self(0i32);
9264 pub const SHADERS: Self = Self(1i32);
9265 #[inline]
9266 pub const fn from_raw(value: i32) -> Self {
9267 Self(value)
9268 }
9269 #[inline]
9270 pub const fn as_raw(self) -> i32 {
9271 self.0
9272 }
9273}
9274impl core::fmt::Debug for ValidationCheckEXT {
9275 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9276 match self.0 {
9277 0i32 => f.write_str("ALL"),
9278 1i32 => f.write_str("SHADERS"),
9279 other => write!(f, "{}({})", stringify!(ValidationCheckEXT), other),
9280 }
9281 }
9282}
9283#[repr(transparent)]
9285#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9286#[doc(alias = "VkValidationFeatureDisableEXT")]
9287pub struct ValidationFeatureDisableEXT(i32);
9288impl ValidationFeatureDisableEXT {
9289 pub const ALL: Self = Self(0i32);
9290 pub const SHADERS: Self = Self(1i32);
9291 pub const THREAD_SAFETY: Self = Self(2i32);
9292 pub const API_PARAMETERS: Self = Self(3i32);
9293 pub const OBJECT_LIFETIMES: Self = Self(4i32);
9294 pub const CORE_CHECKS: Self = Self(5i32);
9295 pub const UNIQUE_HANDLES: Self = Self(6i32);
9296 pub const SHADER_VALIDATION_CACHE: Self = Self(7i32);
9297 #[inline]
9298 pub const fn from_raw(value: i32) -> Self {
9299 Self(value)
9300 }
9301 #[inline]
9302 pub const fn as_raw(self) -> i32 {
9303 self.0
9304 }
9305}
9306impl core::fmt::Debug for ValidationFeatureDisableEXT {
9307 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9308 match self.0 {
9309 0i32 => f.write_str("ALL"),
9310 1i32 => f.write_str("SHADERS"),
9311 2i32 => f.write_str("THREAD_SAFETY"),
9312 3i32 => f.write_str("API_PARAMETERS"),
9313 4i32 => f.write_str("OBJECT_LIFETIMES"),
9314 5i32 => f.write_str("CORE_CHECKS"),
9315 6i32 => f.write_str("UNIQUE_HANDLES"),
9316 7i32 => f.write_str("SHADER_VALIDATION_CACHE"),
9317 other => write!(f, "{}({})", stringify!(ValidationFeatureDisableEXT), other),
9318 }
9319 }
9320}
9321#[repr(transparent)]
9323#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9324#[doc(alias = "VkValidationFeatureEnableEXT")]
9325pub struct ValidationFeatureEnableEXT(i32);
9326impl ValidationFeatureEnableEXT {
9327 pub const GPU_ASSISTED: Self = Self(0i32);
9328 pub const GPU_ASSISTED_RESERVE_BINDING_SLOT: Self = Self(1i32);
9329 pub const BEST_PRACTICES: Self = Self(2i32);
9330 pub const DEBUG_PRINTF: Self = Self(3i32);
9331 pub const SYNCHRONIZATION_VALIDATION: Self = Self(4i32);
9332 #[inline]
9333 pub const fn from_raw(value: i32) -> Self {
9334 Self(value)
9335 }
9336 #[inline]
9337 pub const fn as_raw(self) -> i32 {
9338 self.0
9339 }
9340}
9341impl core::fmt::Debug for ValidationFeatureEnableEXT {
9342 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9343 match self.0 {
9344 0i32 => f.write_str("GPU_ASSISTED"),
9345 1i32 => f.write_str("GPU_ASSISTED_RESERVE_BINDING_SLOT"),
9346 2i32 => f.write_str("BEST_PRACTICES"),
9347 3i32 => f.write_str("DEBUG_PRINTF"),
9348 4i32 => f.write_str("SYNCHRONIZATION_VALIDATION"),
9349 other => write!(f, "{}({})", stringify!(ValidationFeatureEnableEXT), other),
9350 }
9351 }
9352}
9353#[repr(transparent)]
9355#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9356#[doc(alias = "VkVendorId")]
9357pub struct VendorId(i32);
9358impl VendorId {
9359 pub const KHRONOS: Self = Self(65536i32);
9361 pub const VIV: Self = Self(65537i32);
9363 pub const VSI: Self = Self(65538i32);
9365 pub const KAZAN: Self = Self(65539i32);
9367 pub const CODEPLAY: Self = Self(65540i32);
9369 pub const POCL: Self = Self(65542i32);
9371 pub const MOBILEYE: Self = Self(65543i32);
9373 #[inline]
9374 pub const fn from_raw(value: i32) -> Self {
9375 Self(value)
9376 }
9377 #[inline]
9378 pub const fn as_raw(self) -> i32 {
9379 self.0
9380 }
9381}
9382impl core::fmt::Debug for VendorId {
9383 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9384 match self.0 {
9385 65536i32 => f.write_str("KHRONOS"),
9386 65537i32 => f.write_str("VIV"),
9387 65538i32 => f.write_str("VSI"),
9388 65539i32 => f.write_str("KAZAN"),
9389 65540i32 => f.write_str("CODEPLAY"),
9390 65542i32 => f.write_str("POCL"),
9391 65543i32 => f.write_str("MOBILEYE"),
9392 other => write!(f, "{}({})", stringify!(VendorId), other),
9393 }
9394 }
9395}
9396#[repr(transparent)]
9398#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9399#[doc(alias = "VkVertexInputRate")]
9400pub struct VertexInputRate(i32);
9401impl VertexInputRate {
9402 pub const VERTEX: Self = Self(0i32);
9403 pub const INSTANCE: Self = Self(1i32);
9404 #[inline]
9405 pub const fn from_raw(value: i32) -> Self {
9406 Self(value)
9407 }
9408 #[inline]
9409 pub const fn as_raw(self) -> i32 {
9410 self.0
9411 }
9412}
9413impl core::fmt::Debug for VertexInputRate {
9414 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9415 match self.0 {
9416 0i32 => f.write_str("VERTEX"),
9417 1i32 => f.write_str("INSTANCE"),
9418 other => write!(f, "{}({})", stringify!(VertexInputRate), other),
9419 }
9420 }
9421}
9422#[repr(transparent)]
9424#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9425#[doc(alias = "VkVideoEncodeAV1PredictionModeKHR")]
9426pub struct VideoEncodeAV1PredictionModeKHR(i32);
9427impl VideoEncodeAV1PredictionModeKHR {
9428 pub const INTRA_ONLY: Self = Self(0i32);
9429 pub const SINGLE_REFERENCE: Self = Self(1i32);
9430 pub const UNIDIRECTIONAL_COMPOUND: Self = Self(2i32);
9431 pub const BIDIRECTIONAL_COMPOUND: Self = Self(3i32);
9432 #[inline]
9433 pub const fn from_raw(value: i32) -> Self {
9434 Self(value)
9435 }
9436 #[inline]
9437 pub const fn as_raw(self) -> i32 {
9438 self.0
9439 }
9440}
9441impl core::fmt::Debug for VideoEncodeAV1PredictionModeKHR {
9442 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9443 match self.0 {
9444 0i32 => f.write_str("INTRA_ONLY"),
9445 1i32 => f.write_str("SINGLE_REFERENCE"),
9446 2i32 => f.write_str("UNIDIRECTIONAL_COMPOUND"),
9447 3i32 => f.write_str("BIDIRECTIONAL_COMPOUND"),
9448 other => {
9449 write!(f, "{}({})", stringify!(VideoEncodeAV1PredictionModeKHR), other)
9450 }
9451 }
9452 }
9453}
9454#[repr(transparent)]
9456#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9457#[doc(alias = "VkVideoEncodeAV1RateControlGroupKHR")]
9458pub struct VideoEncodeAV1RateControlGroupKHR(i32);
9459impl VideoEncodeAV1RateControlGroupKHR {
9460 pub const INTRA: Self = Self(0i32);
9461 pub const PREDICTIVE: Self = Self(1i32);
9462 pub const BIPREDICTIVE: Self = Self(2i32);
9463 #[inline]
9464 pub const fn from_raw(value: i32) -> Self {
9465 Self(value)
9466 }
9467 #[inline]
9468 pub const fn as_raw(self) -> i32 {
9469 self.0
9470 }
9471}
9472impl core::fmt::Debug for VideoEncodeAV1RateControlGroupKHR {
9473 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9474 match self.0 {
9475 0i32 => f.write_str("INTRA"),
9476 1i32 => f.write_str("PREDICTIVE"),
9477 2i32 => f.write_str("BIPREDICTIVE"),
9478 other => {
9479 write!(f, "{}({})", stringify!(VideoEncodeAV1RateControlGroupKHR), other)
9480 }
9481 }
9482 }
9483}
9484#[repr(transparent)]
9486#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9487#[doc(alias = "VkVideoEncodeTuningModeKHR")]
9488pub struct VideoEncodeTuningModeKHR(i32);
9489impl VideoEncodeTuningModeKHR {
9490 pub const DEFAULT: Self = Self(0i32);
9491 pub const HIGH_QUALITY: Self = Self(1i32);
9492 pub const LOW_LATENCY: Self = Self(2i32);
9493 pub const ULTRA_LOW_LATENCY: Self = Self(3i32);
9494 pub const LOSSLESS: Self = Self(4i32);
9495 #[inline]
9496 pub const fn from_raw(value: i32) -> Self {
9497 Self(value)
9498 }
9499 #[inline]
9500 pub const fn as_raw(self) -> i32 {
9501 self.0
9502 }
9503}
9504impl core::fmt::Debug for VideoEncodeTuningModeKHR {
9505 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9506 match self.0 {
9507 0i32 => f.write_str("DEFAULT"),
9508 1i32 => f.write_str("HIGH_QUALITY"),
9509 2i32 => f.write_str("LOW_LATENCY"),
9510 3i32 => f.write_str("ULTRA_LOW_LATENCY"),
9511 4i32 => f.write_str("LOSSLESS"),
9512 other => write!(f, "{}({})", stringify!(VideoEncodeTuningModeKHR), other),
9513 }
9514 }
9515}
9516#[repr(transparent)]
9518#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9519#[doc(alias = "VkViewportCoordinateSwizzleNV")]
9520pub struct ViewportCoordinateSwizzleNV(i32);
9521impl ViewportCoordinateSwizzleNV {
9522 pub const POSITIVE_X: Self = Self(0i32);
9523 pub const NEGATIVE_X: Self = Self(1i32);
9524 pub const POSITIVE_Y: Self = Self(2i32);
9525 pub const NEGATIVE_Y: Self = Self(3i32);
9526 pub const POSITIVE_Z: Self = Self(4i32);
9527 pub const NEGATIVE_Z: Self = Self(5i32);
9528 pub const POSITIVE_W: Self = Self(6i32);
9529 pub const NEGATIVE_W: Self = Self(7i32);
9530 #[inline]
9531 pub const fn from_raw(value: i32) -> Self {
9532 Self(value)
9533 }
9534 #[inline]
9535 pub const fn as_raw(self) -> i32 {
9536 self.0
9537 }
9538}
9539impl core::fmt::Debug for ViewportCoordinateSwizzleNV {
9540 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9541 match self.0 {
9542 0i32 => f.write_str("POSITIVE_X"),
9543 1i32 => f.write_str("NEGATIVE_X"),
9544 2i32 => f.write_str("POSITIVE_Y"),
9545 3i32 => f.write_str("NEGATIVE_Y"),
9546 4i32 => f.write_str("POSITIVE_Z"),
9547 5i32 => f.write_str("NEGATIVE_Z"),
9548 6i32 => f.write_str("POSITIVE_W"),
9549 7i32 => f.write_str("NEGATIVE_W"),
9550 other => write!(f, "{}({})", stringify!(ViewportCoordinateSwizzleNV), other),
9551 }
9552 }
9553}