1use crate::prelude::debug_flags;
2use crate::vk::bitflags::*;
3use crate::vk::definitions::*;
4use crate::vk::enums::*;
5use std::fmt;
6impl fmt::Debug for AccelerationStructureBuildTypeKHR {
7 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
8 let name = match *self {
9 Self::HOST => Some("HOST"),
10 Self::DEVICE => Some("DEVICE"),
11 Self::HOST_OR_DEVICE => Some("HOST_OR_DEVICE"),
12 _ => None,
13 };
14 if let Some(x) = name {
15 f.write_str(x)
16 } else {
17 self.0.fmt(f)
18 }
19 }
20}
21impl fmt::Debug for AccelerationStructureCompatibilityKHR {
22 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
23 let name = match *self {
24 Self::COMPATIBLE => Some("COMPATIBLE"),
25 Self::INCOMPATIBLE => Some("INCOMPATIBLE"),
26 _ => None,
27 };
28 if let Some(x) = name {
29 f.write_str(x)
30 } else {
31 self.0.fmt(f)
32 }
33 }
34}
35impl fmt::Debug for AccelerationStructureCreateFlagsKHR {
36 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
37 const KNOWN: &[(Flags, &str)] = &[
38 (
39 AccelerationStructureCreateFlagsKHR::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
40 "DEVICE_ADDRESS_CAPTURE_REPLAY",
41 ),
42 (
43 AccelerationStructureCreateFlagsKHR::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
44 "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
45 ),
46 (
47 AccelerationStructureCreateFlagsKHR::MOTION_NV.0,
48 "MOTION_NV",
49 ),
50 ];
51 debug_flags(f, KNOWN, self.0)
52 }
53}
54impl fmt::Debug for AccelerationStructureMemoryRequirementsTypeNV {
55 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
56 let name = match *self {
57 Self::OBJECT => Some("OBJECT"),
58 Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"),
59 Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"),
60 _ => None,
61 };
62 if let Some(x) = name {
63 f.write_str(x)
64 } else {
65 self.0.fmt(f)
66 }
67 }
68}
69impl fmt::Debug for AccelerationStructureMotionInfoFlagsNV {
70 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
71 const KNOWN: &[(Flags, &str)] = &[];
72 debug_flags(f, KNOWN, self.0)
73 }
74}
75impl fmt::Debug for AccelerationStructureMotionInstanceFlagsNV {
76 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
77 const KNOWN: &[(Flags, &str)] = &[];
78 debug_flags(f, KNOWN, self.0)
79 }
80}
81impl fmt::Debug for AccelerationStructureMotionInstanceTypeNV {
82 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
83 let name = match *self {
84 Self::STATIC => Some("STATIC"),
85 Self::MATRIX_MOTION => Some("MATRIX_MOTION"),
86 Self::SRT_MOTION => Some("SRT_MOTION"),
87 _ => None,
88 };
89 if let Some(x) = name {
90 f.write_str(x)
91 } else {
92 self.0.fmt(f)
93 }
94 }
95}
96impl fmt::Debug for AccelerationStructureTypeKHR {
97 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
98 let name = match *self {
99 Self::TOP_LEVEL => Some("TOP_LEVEL"),
100 Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"),
101 Self::GENERIC => Some("GENERIC"),
102 _ => None,
103 };
104 if let Some(x) = name {
105 f.write_str(x)
106 } else {
107 self.0.fmt(f)
108 }
109 }
110}
111impl fmt::Debug for AccessFlags {
112 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
113 const KNOWN: &[(Flags, &str)] = &[
114 (
115 AccessFlags::INDIRECT_COMMAND_READ.0,
116 "INDIRECT_COMMAND_READ",
117 ),
118 (AccessFlags::INDEX_READ.0, "INDEX_READ"),
119 (
120 AccessFlags::VERTEX_ATTRIBUTE_READ.0,
121 "VERTEX_ATTRIBUTE_READ",
122 ),
123 (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"),
124 (
125 AccessFlags::INPUT_ATTACHMENT_READ.0,
126 "INPUT_ATTACHMENT_READ",
127 ),
128 (AccessFlags::SHADER_READ.0, "SHADER_READ"),
129 (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"),
130 (
131 AccessFlags::COLOR_ATTACHMENT_READ.0,
132 "COLOR_ATTACHMENT_READ",
133 ),
134 (
135 AccessFlags::COLOR_ATTACHMENT_WRITE.0,
136 "COLOR_ATTACHMENT_WRITE",
137 ),
138 (
139 AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0,
140 "DEPTH_STENCIL_ATTACHMENT_READ",
141 ),
142 (
143 AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0,
144 "DEPTH_STENCIL_ATTACHMENT_WRITE",
145 ),
146 (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"),
147 (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"),
148 (AccessFlags::HOST_READ.0, "HOST_READ"),
149 (AccessFlags::HOST_WRITE.0, "HOST_WRITE"),
150 (AccessFlags::MEMORY_READ.0, "MEMORY_READ"),
151 (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"),
152 (
153 AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0,
154 "TRANSFORM_FEEDBACK_WRITE_EXT",
155 ),
156 (
157 AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0,
158 "TRANSFORM_FEEDBACK_COUNTER_READ_EXT",
159 ),
160 (
161 AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0,
162 "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT",
163 ),
164 (
165 AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0,
166 "CONDITIONAL_RENDERING_READ_EXT",
167 ),
168 (
169 AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0,
170 "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT",
171 ),
172 (
173 AccessFlags::ACCELERATION_STRUCTURE_READ_KHR.0,
174 "ACCELERATION_STRUCTURE_READ_KHR",
175 ),
176 (
177 AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR.0,
178 "ACCELERATION_STRUCTURE_WRITE_KHR",
179 ),
180 (
181 AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0,
182 "FRAGMENT_DENSITY_MAP_READ_EXT",
183 ),
184 (
185 AccessFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0,
186 "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR",
187 ),
188 (
189 AccessFlags::COMMAND_PREPROCESS_READ_NV.0,
190 "COMMAND_PREPROCESS_READ_NV",
191 ),
192 (
193 AccessFlags::COMMAND_PREPROCESS_WRITE_NV.0,
194 "COMMAND_PREPROCESS_WRITE_NV",
195 ),
196 (AccessFlags::NONE.0, "NONE"),
197 ];
198 debug_flags(f, KNOWN, self.0)
199 }
200}
201impl fmt::Debug for AccessFlags2 {
202 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
203 const KNOWN: &[(Flags64, &str)] = &[
204 (AccessFlags2::NONE.0, "NONE"),
205 (
206 AccessFlags2::INDIRECT_COMMAND_READ.0,
207 "INDIRECT_COMMAND_READ",
208 ),
209 (AccessFlags2::INDEX_READ.0, "INDEX_READ"),
210 (
211 AccessFlags2::VERTEX_ATTRIBUTE_READ.0,
212 "VERTEX_ATTRIBUTE_READ",
213 ),
214 (AccessFlags2::UNIFORM_READ.0, "UNIFORM_READ"),
215 (
216 AccessFlags2::INPUT_ATTACHMENT_READ.0,
217 "INPUT_ATTACHMENT_READ",
218 ),
219 (AccessFlags2::SHADER_READ.0, "SHADER_READ"),
220 (AccessFlags2::SHADER_WRITE.0, "SHADER_WRITE"),
221 (
222 AccessFlags2::COLOR_ATTACHMENT_READ.0,
223 "COLOR_ATTACHMENT_READ",
224 ),
225 (
226 AccessFlags2::COLOR_ATTACHMENT_WRITE.0,
227 "COLOR_ATTACHMENT_WRITE",
228 ),
229 (
230 AccessFlags2::DEPTH_STENCIL_ATTACHMENT_READ.0,
231 "DEPTH_STENCIL_ATTACHMENT_READ",
232 ),
233 (
234 AccessFlags2::DEPTH_STENCIL_ATTACHMENT_WRITE.0,
235 "DEPTH_STENCIL_ATTACHMENT_WRITE",
236 ),
237 (AccessFlags2::TRANSFER_READ.0, "TRANSFER_READ"),
238 (AccessFlags2::TRANSFER_WRITE.0, "TRANSFER_WRITE"),
239 (AccessFlags2::HOST_READ.0, "HOST_READ"),
240 (AccessFlags2::HOST_WRITE.0, "HOST_WRITE"),
241 (AccessFlags2::MEMORY_READ.0, "MEMORY_READ"),
242 (AccessFlags2::MEMORY_WRITE.0, "MEMORY_WRITE"),
243 (AccessFlags2::SHADER_SAMPLED_READ.0, "SHADER_SAMPLED_READ"),
244 (AccessFlags2::SHADER_STORAGE_READ.0, "SHADER_STORAGE_READ"),
245 (AccessFlags2::SHADER_STORAGE_WRITE.0, "SHADER_STORAGE_WRITE"),
246 (
247 AccessFlags2::VIDEO_DECODE_READ_KHR.0,
248 "VIDEO_DECODE_READ_KHR",
249 ),
250 (
251 AccessFlags2::VIDEO_DECODE_WRITE_KHR.0,
252 "VIDEO_DECODE_WRITE_KHR",
253 ),
254 (AccessFlags2::RESERVED_46_EXT.0, "RESERVED_46_EXT"),
255 (
256 AccessFlags2::VIDEO_ENCODE_READ_KHR.0,
257 "VIDEO_ENCODE_READ_KHR",
258 ),
259 (
260 AccessFlags2::VIDEO_ENCODE_WRITE_KHR.0,
261 "VIDEO_ENCODE_WRITE_KHR",
262 ),
263 (
264 AccessFlags2::TRANSFORM_FEEDBACK_WRITE_EXT.0,
265 "TRANSFORM_FEEDBACK_WRITE_EXT",
266 ),
267 (
268 AccessFlags2::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0,
269 "TRANSFORM_FEEDBACK_COUNTER_READ_EXT",
270 ),
271 (
272 AccessFlags2::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0,
273 "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT",
274 ),
275 (
276 AccessFlags2::CONDITIONAL_RENDERING_READ_EXT.0,
277 "CONDITIONAL_RENDERING_READ_EXT",
278 ),
279 (
280 AccessFlags2::COMMAND_PREPROCESS_READ_NV.0,
281 "COMMAND_PREPROCESS_READ_NV",
282 ),
283 (
284 AccessFlags2::COMMAND_PREPROCESS_WRITE_NV.0,
285 "COMMAND_PREPROCESS_WRITE_NV",
286 ),
287 (
288 AccessFlags2::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0,
289 "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR",
290 ),
291 (
292 AccessFlags2::ACCELERATION_STRUCTURE_READ_KHR.0,
293 "ACCELERATION_STRUCTURE_READ_KHR",
294 ),
295 (
296 AccessFlags2::ACCELERATION_STRUCTURE_WRITE_KHR.0,
297 "ACCELERATION_STRUCTURE_WRITE_KHR",
298 ),
299 (
300 AccessFlags2::FRAGMENT_DENSITY_MAP_READ_EXT.0,
301 "FRAGMENT_DENSITY_MAP_READ_EXT",
302 ),
303 (
304 AccessFlags2::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0,
305 "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT",
306 ),
307 (
308 AccessFlags2::DESCRIPTOR_BUFFER_READ_EXT.0,
309 "DESCRIPTOR_BUFFER_READ_EXT",
310 ),
311 (
312 AccessFlags2::INVOCATION_MASK_READ_HUAWEI.0,
313 "INVOCATION_MASK_READ_HUAWEI",
314 ),
315 (
316 AccessFlags2::SHADER_BINDING_TABLE_READ_KHR.0,
317 "SHADER_BINDING_TABLE_READ_KHR",
318 ),
319 (AccessFlags2::MICROMAP_READ_EXT.0, "MICROMAP_READ_EXT"),
320 (AccessFlags2::MICROMAP_WRITE_EXT.0, "MICROMAP_WRITE_EXT"),
321 (AccessFlags2::RESERVED_49_ARM.0, "RESERVED_49_ARM"),
322 (AccessFlags2::RESERVED_50_ARM.0, "RESERVED_50_ARM"),
323 (AccessFlags2::OPTICAL_FLOW_READ_NV.0, "OPTICAL_FLOW_READ_NV"),
324 (
325 AccessFlags2::OPTICAL_FLOW_WRITE_NV.0,
326 "OPTICAL_FLOW_WRITE_NV",
327 ),
328 (AccessFlags2::RESERVED_47_EXT.0, "RESERVED_47_EXT"),
329 (AccessFlags2::RESERVED_48_EXT.0, "RESERVED_48_EXT"),
330 ];
331 debug_flags(f, KNOWN, self.0)
332 }
333}
334impl fmt::Debug for AcquireProfilingLockFlagsKHR {
335 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
336 const KNOWN: &[(Flags, &str)] = &[];
337 debug_flags(f, KNOWN, self.0)
338 }
339}
340impl fmt::Debug for AndroidSurfaceCreateFlagsKHR {
341 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
342 const KNOWN: &[(Flags, &str)] = &[];
343 debug_flags(f, KNOWN, self.0)
344 }
345}
346impl fmt::Debug for AttachmentDescriptionFlags {
347 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
348 const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")];
349 debug_flags(f, KNOWN, self.0)
350 }
351}
352impl fmt::Debug for AttachmentLoadOp {
353 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
354 let name = match *self {
355 Self::LOAD => Some("LOAD"),
356 Self::CLEAR => Some("CLEAR"),
357 Self::DONT_CARE => Some("DONT_CARE"),
358 Self::NONE_EXT => Some("NONE_EXT"),
359 _ => None,
360 };
361 if let Some(x) = name {
362 f.write_str(x)
363 } else {
364 self.0.fmt(f)
365 }
366 }
367}
368impl fmt::Debug for AttachmentStoreOp {
369 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
370 let name = match *self {
371 Self::STORE => Some("STORE"),
372 Self::DONT_CARE => Some("DONT_CARE"),
373 Self::NONE => Some("NONE"),
374 _ => None,
375 };
376 if let Some(x) = name {
377 f.write_str(x)
378 } else {
379 self.0.fmt(f)
380 }
381 }
382}
383impl fmt::Debug for BlendFactor {
384 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
385 let name = match *self {
386 Self::ZERO => Some("ZERO"),
387 Self::ONE => Some("ONE"),
388 Self::SRC_COLOR => Some("SRC_COLOR"),
389 Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"),
390 Self::DST_COLOR => Some("DST_COLOR"),
391 Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"),
392 Self::SRC_ALPHA => Some("SRC_ALPHA"),
393 Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"),
394 Self::DST_ALPHA => Some("DST_ALPHA"),
395 Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"),
396 Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"),
397 Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"),
398 Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"),
399 Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"),
400 Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"),
401 Self::SRC1_COLOR => Some("SRC1_COLOR"),
402 Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"),
403 Self::SRC1_ALPHA => Some("SRC1_ALPHA"),
404 Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"),
405 _ => None,
406 };
407 if let Some(x) = name {
408 f.write_str(x)
409 } else {
410 self.0.fmt(f)
411 }
412 }
413}
414impl fmt::Debug for BlendOp {
415 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
416 let name = match *self {
417 Self::ADD => Some("ADD"),
418 Self::SUBTRACT => Some("SUBTRACT"),
419 Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"),
420 Self::MIN => Some("MIN"),
421 Self::MAX => Some("MAX"),
422 Self::ZERO_EXT => Some("ZERO_EXT"),
423 Self::SRC_EXT => Some("SRC_EXT"),
424 Self::DST_EXT => Some("DST_EXT"),
425 Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"),
426 Self::DST_OVER_EXT => Some("DST_OVER_EXT"),
427 Self::SRC_IN_EXT => Some("SRC_IN_EXT"),
428 Self::DST_IN_EXT => Some("DST_IN_EXT"),
429 Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"),
430 Self::DST_OUT_EXT => Some("DST_OUT_EXT"),
431 Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"),
432 Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"),
433 Self::XOR_EXT => Some("XOR_EXT"),
434 Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"),
435 Self::SCREEN_EXT => Some("SCREEN_EXT"),
436 Self::OVERLAY_EXT => Some("OVERLAY_EXT"),
437 Self::DARKEN_EXT => Some("DARKEN_EXT"),
438 Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"),
439 Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"),
440 Self::COLORBURN_EXT => Some("COLORBURN_EXT"),
441 Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"),
442 Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"),
443 Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"),
444 Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"),
445 Self::INVERT_EXT => Some("INVERT_EXT"),
446 Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"),
447 Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"),
448 Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"),
449 Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"),
450 Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"),
451 Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"),
452 Self::HARDMIX_EXT => Some("HARDMIX_EXT"),
453 Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"),
454 Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"),
455 Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"),
456 Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"),
457 Self::PLUS_EXT => Some("PLUS_EXT"),
458 Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"),
459 Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"),
460 Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"),
461 Self::MINUS_EXT => Some("MINUS_EXT"),
462 Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"),
463 Self::CONTRAST_EXT => Some("CONTRAST_EXT"),
464 Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"),
465 Self::RED_EXT => Some("RED_EXT"),
466 Self::GREEN_EXT => Some("GREEN_EXT"),
467 Self::BLUE_EXT => Some("BLUE_EXT"),
468 _ => None,
469 };
470 if let Some(x) = name {
471 f.write_str(x)
472 } else {
473 self.0.fmt(f)
474 }
475 }
476}
477impl fmt::Debug for BlendOverlapEXT {
478 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
479 let name = match *self {
480 Self::UNCORRELATED => Some("UNCORRELATED"),
481 Self::DISJOINT => Some("DISJOINT"),
482 Self::CONJOINT => Some("CONJOINT"),
483 _ => None,
484 };
485 if let Some(x) = name {
486 f.write_str(x)
487 } else {
488 self.0.fmt(f)
489 }
490 }
491}
492impl fmt::Debug for BorderColor {
493 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
494 let name = match *self {
495 Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"),
496 Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"),
497 Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"),
498 Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"),
499 Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"),
500 Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"),
501 Self::FLOAT_CUSTOM_EXT => Some("FLOAT_CUSTOM_EXT"),
502 Self::INT_CUSTOM_EXT => Some("INT_CUSTOM_EXT"),
503 _ => None,
504 };
505 if let Some(x) = name {
506 f.write_str(x)
507 } else {
508 self.0.fmt(f)
509 }
510 }
511}
512impl fmt::Debug for BufferCreateFlags {
513 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
514 const KNOWN: &[(Flags, &str)] = &[
515 (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"),
516 (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"),
517 (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"),
518 (
519 BufferCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
520 "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
521 ),
522 (BufferCreateFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"),
523 (BufferCreateFlags::PROTECTED.0, "PROTECTED"),
524 (
525 BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
526 "DEVICE_ADDRESS_CAPTURE_REPLAY",
527 ),
528 ];
529 debug_flags(f, KNOWN, self.0)
530 }
531}
532impl fmt::Debug for BufferUsageFlags {
533 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
534 const KNOWN: &[(Flags, &str)] = &[
535 (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"),
536 (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"),
537 (
538 BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0,
539 "UNIFORM_TEXEL_BUFFER",
540 ),
541 (
542 BufferUsageFlags::STORAGE_TEXEL_BUFFER.0,
543 "STORAGE_TEXEL_BUFFER",
544 ),
545 (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"),
546 (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"),
547 (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"),
548 (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"),
549 (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"),
550 (
551 BufferUsageFlags::VIDEO_DECODE_SRC_KHR.0,
552 "VIDEO_DECODE_SRC_KHR",
553 ),
554 (
555 BufferUsageFlags::VIDEO_DECODE_DST_KHR.0,
556 "VIDEO_DECODE_DST_KHR",
557 ),
558 (
559 BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0,
560 "TRANSFORM_FEEDBACK_BUFFER_EXT",
561 ),
562 (
563 BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0,
564 "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT",
565 ),
566 (
567 BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0,
568 "CONDITIONAL_RENDERING_EXT",
569 ),
570 (BufferUsageFlags::RESERVED_25_AMD.0, "RESERVED_25_AMD"),
571 (
572 BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0,
573 "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR",
574 ),
575 (
576 BufferUsageFlags::ACCELERATION_STRUCTURE_STORAGE_KHR.0,
577 "ACCELERATION_STRUCTURE_STORAGE_KHR",
578 ),
579 (
580 BufferUsageFlags::SHADER_BINDING_TABLE_KHR.0,
581 "SHADER_BINDING_TABLE_KHR",
582 ),
583 (BufferUsageFlags::RESERVED_18_QCOM.0, "RESERVED_18_QCOM"),
584 (
585 BufferUsageFlags::VIDEO_ENCODE_DST_KHR.0,
586 "VIDEO_ENCODE_DST_KHR",
587 ),
588 (
589 BufferUsageFlags::VIDEO_ENCODE_SRC_KHR.0,
590 "VIDEO_ENCODE_SRC_KHR",
591 ),
592 (
593 BufferUsageFlags::SAMPLER_DESCRIPTOR_BUFFER_EXT.0,
594 "SAMPLER_DESCRIPTOR_BUFFER_EXT",
595 ),
596 (
597 BufferUsageFlags::RESOURCE_DESCRIPTOR_BUFFER_EXT.0,
598 "RESOURCE_DESCRIPTOR_BUFFER_EXT",
599 ),
600 (
601 BufferUsageFlags::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT.0,
602 "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT",
603 ),
604 (
605 BufferUsageFlags::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0,
606 "MICROMAP_BUILD_INPUT_READ_ONLY_EXT",
607 ),
608 (
609 BufferUsageFlags::MICROMAP_STORAGE_EXT.0,
610 "MICROMAP_STORAGE_EXT",
611 ),
612 (
613 BufferUsageFlags::SHADER_DEVICE_ADDRESS.0,
614 "SHADER_DEVICE_ADDRESS",
615 ),
616 ];
617 debug_flags(f, KNOWN, self.0)
618 }
619}
620impl fmt::Debug for BufferViewCreateFlags {
621 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
622 const KNOWN: &[(Flags, &str)] = &[];
623 debug_flags(f, KNOWN, self.0)
624 }
625}
626impl fmt::Debug for BuildAccelerationStructureFlagsKHR {
627 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
628 const KNOWN: &[(Flags, &str)] = &[
629 (
630 BuildAccelerationStructureFlagsKHR::ALLOW_UPDATE.0,
631 "ALLOW_UPDATE",
632 ),
633 (
634 BuildAccelerationStructureFlagsKHR::ALLOW_COMPACTION.0,
635 "ALLOW_COMPACTION",
636 ),
637 (
638 BuildAccelerationStructureFlagsKHR::PREFER_FAST_TRACE.0,
639 "PREFER_FAST_TRACE",
640 ),
641 (
642 BuildAccelerationStructureFlagsKHR::PREFER_FAST_BUILD.0,
643 "PREFER_FAST_BUILD",
644 ),
645 (
646 BuildAccelerationStructureFlagsKHR::LOW_MEMORY.0,
647 "LOW_MEMORY",
648 ),
649 (BuildAccelerationStructureFlagsKHR::MOTION_NV.0, "MOTION_NV"),
650 (
651 BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_UPDATE_EXT.0,
652 "ALLOW_OPACITY_MICROMAP_UPDATE_EXT",
653 ),
654 (
655 BuildAccelerationStructureFlagsKHR::ALLOW_DISABLE_OPACITY_MICROMAPS_EXT.0,
656 "ALLOW_DISABLE_OPACITY_MICROMAPS_EXT",
657 ),
658 (
659 BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT.0,
660 "ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT",
661 ),
662 (
663 BuildAccelerationStructureFlagsKHR::ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV.0,
664 "ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV",
665 ),
666 (
667 BuildAccelerationStructureFlagsKHR::ALLOW_DATA_ACCESS.0,
668 "ALLOW_DATA_ACCESS",
669 ),
670 ];
671 debug_flags(f, KNOWN, self.0)
672 }
673}
674impl fmt::Debug for BuildAccelerationStructureModeKHR {
675 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
676 let name = match *self {
677 Self::BUILD => Some("BUILD"),
678 Self::UPDATE => Some("UPDATE"),
679 _ => None,
680 };
681 if let Some(x) = name {
682 f.write_str(x)
683 } else {
684 self.0.fmt(f)
685 }
686 }
687}
688impl fmt::Debug for BuildMicromapFlagsEXT {
689 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
690 const KNOWN: &[(Flags, &str)] = &[
691 (
692 BuildMicromapFlagsEXT::PREFER_FAST_TRACE.0,
693 "PREFER_FAST_TRACE",
694 ),
695 (
696 BuildMicromapFlagsEXT::PREFER_FAST_BUILD.0,
697 "PREFER_FAST_BUILD",
698 ),
699 (
700 BuildMicromapFlagsEXT::ALLOW_COMPACTION.0,
701 "ALLOW_COMPACTION",
702 ),
703 ];
704 debug_flags(f, KNOWN, self.0)
705 }
706}
707impl fmt::Debug for BuildMicromapModeEXT {
708 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
709 let name = match *self {
710 Self::BUILD => Some("BUILD"),
711 _ => None,
712 };
713 if let Some(x) = name {
714 f.write_str(x)
715 } else {
716 self.0.fmt(f)
717 }
718 }
719}
720impl fmt::Debug for ChromaLocation {
721 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
722 let name = match *self {
723 Self::COSITED_EVEN => Some("COSITED_EVEN"),
724 Self::MIDPOINT => Some("MIDPOINT"),
725 _ => None,
726 };
727 if let Some(x) = name {
728 f.write_str(x)
729 } else {
730 self.0.fmt(f)
731 }
732 }
733}
734impl fmt::Debug for CoarseSampleOrderTypeNV {
735 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
736 let name = match *self {
737 Self::DEFAULT => Some("DEFAULT"),
738 Self::CUSTOM => Some("CUSTOM"),
739 Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"),
740 Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"),
741 _ => None,
742 };
743 if let Some(x) = name {
744 f.write_str(x)
745 } else {
746 self.0.fmt(f)
747 }
748 }
749}
750impl fmt::Debug for ColorComponentFlags {
751 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
752 const KNOWN: &[(Flags, &str)] = &[
753 (ColorComponentFlags::R.0, "R"),
754 (ColorComponentFlags::G.0, "G"),
755 (ColorComponentFlags::B.0, "B"),
756 (ColorComponentFlags::A.0, "A"),
757 ];
758 debug_flags(f, KNOWN, self.0)
759 }
760}
761impl fmt::Debug for ColorSpaceKHR {
762 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
763 let name = match *self {
764 Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"),
765 Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"),
766 Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"),
767 Self::DISPLAY_P3_LINEAR_EXT => Some("DISPLAY_P3_LINEAR_EXT"),
768 Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"),
769 Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"),
770 Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"),
771 Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"),
772 Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"),
773 Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"),
774 Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"),
775 Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"),
776 Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"),
777 Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"),
778 Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"),
779 Self::DISPLAY_NATIVE_AMD => Some("DISPLAY_NATIVE_AMD"),
780 _ => None,
781 };
782 if let Some(x) = name {
783 f.write_str(x)
784 } else {
785 self.0.fmt(f)
786 }
787 }
788}
789impl fmt::Debug for CommandBufferLevel {
790 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
791 let name = match *self {
792 Self::PRIMARY => Some("PRIMARY"),
793 Self::SECONDARY => Some("SECONDARY"),
794 _ => None,
795 };
796 if let Some(x) = name {
797 f.write_str(x)
798 } else {
799 self.0.fmt(f)
800 }
801 }
802}
803impl fmt::Debug for CommandBufferResetFlags {
804 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
805 const KNOWN: &[(Flags, &str)] = &[(
806 CommandBufferResetFlags::RELEASE_RESOURCES.0,
807 "RELEASE_RESOURCES",
808 )];
809 debug_flags(f, KNOWN, self.0)
810 }
811}
812impl fmt::Debug for CommandBufferUsageFlags {
813 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
814 const KNOWN: &[(Flags, &str)] = &[
815 (
816 CommandBufferUsageFlags::ONE_TIME_SUBMIT.0,
817 "ONE_TIME_SUBMIT",
818 ),
819 (
820 CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0,
821 "RENDER_PASS_CONTINUE",
822 ),
823 (
824 CommandBufferUsageFlags::SIMULTANEOUS_USE.0,
825 "SIMULTANEOUS_USE",
826 ),
827 ];
828 debug_flags(f, KNOWN, self.0)
829 }
830}
831impl fmt::Debug for CommandPoolCreateFlags {
832 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
833 const KNOWN: &[(Flags, &str)] = &[
834 (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"),
835 (
836 CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0,
837 "RESET_COMMAND_BUFFER",
838 ),
839 (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"),
840 ];
841 debug_flags(f, KNOWN, self.0)
842 }
843}
844impl fmt::Debug for CommandPoolResetFlags {
845 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
846 const KNOWN: &[(Flags, &str)] = &[
847 (
848 CommandPoolResetFlags::RELEASE_RESOURCES.0,
849 "RELEASE_RESOURCES",
850 ),
851 (
852 CommandPoolResetFlags::RESERVED_1_COREAVI.0,
853 "RESERVED_1_COREAVI",
854 ),
855 ];
856 debug_flags(f, KNOWN, self.0)
857 }
858}
859impl fmt::Debug for CommandPoolTrimFlags {
860 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
861 const KNOWN: &[(Flags, &str)] = &[];
862 debug_flags(f, KNOWN, self.0)
863 }
864}
865impl fmt::Debug for CompareOp {
866 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
867 let name = match *self {
868 Self::NEVER => Some("NEVER"),
869 Self::LESS => Some("LESS"),
870 Self::EQUAL => Some("EQUAL"),
871 Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"),
872 Self::GREATER => Some("GREATER"),
873 Self::NOT_EQUAL => Some("NOT_EQUAL"),
874 Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"),
875 Self::ALWAYS => Some("ALWAYS"),
876 _ => None,
877 };
878 if let Some(x) = name {
879 f.write_str(x)
880 } else {
881 self.0.fmt(f)
882 }
883 }
884}
885impl fmt::Debug for ComponentSwizzle {
886 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
887 let name = match *self {
888 Self::IDENTITY => Some("IDENTITY"),
889 Self::ZERO => Some("ZERO"),
890 Self::ONE => Some("ONE"),
891 Self::R => Some("R"),
892 Self::G => Some("G"),
893 Self::B => Some("B"),
894 Self::A => Some("A"),
895 _ => None,
896 };
897 if let Some(x) = name {
898 f.write_str(x)
899 } else {
900 self.0.fmt(f)
901 }
902 }
903}
904impl fmt::Debug for ComponentTypeNV {
905 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
906 let name = match *self {
907 Self::FLOAT16 => Some("FLOAT16"),
908 Self::FLOAT32 => Some("FLOAT32"),
909 Self::FLOAT64 => Some("FLOAT64"),
910 Self::SINT8 => Some("SINT8"),
911 Self::SINT16 => Some("SINT16"),
912 Self::SINT32 => Some("SINT32"),
913 Self::SINT64 => Some("SINT64"),
914 Self::UINT8 => Some("UINT8"),
915 Self::UINT16 => Some("UINT16"),
916 Self::UINT32 => Some("UINT32"),
917 Self::UINT64 => Some("UINT64"),
918 _ => None,
919 };
920 if let Some(x) = name {
921 f.write_str(x)
922 } else {
923 self.0.fmt(f)
924 }
925 }
926}
927impl fmt::Debug for CompositeAlphaFlagsKHR {
928 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
929 const KNOWN: &[(Flags, &str)] = &[
930 (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"),
931 (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"),
932 (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"),
933 (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"),
934 ];
935 debug_flags(f, KNOWN, self.0)
936 }
937}
938impl fmt::Debug for ConditionalRenderingFlagsEXT {
939 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
940 const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")];
941 debug_flags(f, KNOWN, self.0)
942 }
943}
944impl fmt::Debug for ConservativeRasterizationModeEXT {
945 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
946 let name = match *self {
947 Self::DISABLED => Some("DISABLED"),
948 Self::OVERESTIMATE => Some("OVERESTIMATE"),
949 Self::UNDERESTIMATE => Some("UNDERESTIMATE"),
950 _ => None,
951 };
952 if let Some(x) = name {
953 f.write_str(x)
954 } else {
955 self.0.fmt(f)
956 }
957 }
958}
959impl fmt::Debug for CopyAccelerationStructureModeKHR {
960 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
961 let name = match *self {
962 Self::CLONE => Some("CLONE"),
963 Self::COMPACT => Some("COMPACT"),
964 Self::SERIALIZE => Some("SERIALIZE"),
965 Self::DESERIALIZE => Some("DESERIALIZE"),
966 _ => None,
967 };
968 if let Some(x) = name {
969 f.write_str(x)
970 } else {
971 self.0.fmt(f)
972 }
973 }
974}
975impl fmt::Debug for CopyMicromapModeEXT {
976 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
977 let name = match *self {
978 Self::CLONE => Some("CLONE"),
979 Self::SERIALIZE => Some("SERIALIZE"),
980 Self::DESERIALIZE => Some("DESERIALIZE"),
981 Self::COMPACT => Some("COMPACT"),
982 _ => None,
983 };
984 if let Some(x) = name {
985 f.write_str(x)
986 } else {
987 self.0.fmt(f)
988 }
989 }
990}
991impl fmt::Debug for CoverageModulationModeNV {
992 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
993 let name = match *self {
994 Self::NONE => Some("NONE"),
995 Self::RGB => Some("RGB"),
996 Self::ALPHA => Some("ALPHA"),
997 Self::RGBA => Some("RGBA"),
998 _ => None,
999 };
1000 if let Some(x) = name {
1001 f.write_str(x)
1002 } else {
1003 self.0.fmt(f)
1004 }
1005 }
1006}
1007impl fmt::Debug for CoverageReductionModeNV {
1008 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1009 let name = match *self {
1010 Self::MERGE => Some("MERGE"),
1011 Self::TRUNCATE => Some("TRUNCATE"),
1012 _ => None,
1013 };
1014 if let Some(x) = name {
1015 f.write_str(x)
1016 } else {
1017 self.0.fmt(f)
1018 }
1019 }
1020}
1021impl fmt::Debug for CullModeFlags {
1022 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1023 const KNOWN: &[(Flags, &str)] = &[
1024 (CullModeFlags::NONE.0, "NONE"),
1025 (CullModeFlags::FRONT.0, "FRONT"),
1026 (CullModeFlags::BACK.0, "BACK"),
1027 (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"),
1028 ];
1029 debug_flags(f, KNOWN, self.0)
1030 }
1031}
1032impl fmt::Debug for DebugReportFlagsEXT {
1033 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1034 const KNOWN: &[(Flags, &str)] = &[
1035 (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"),
1036 (DebugReportFlagsEXT::WARNING.0, "WARNING"),
1037 (
1038 DebugReportFlagsEXT::PERFORMANCE_WARNING.0,
1039 "PERFORMANCE_WARNING",
1040 ),
1041 (DebugReportFlagsEXT::ERROR.0, "ERROR"),
1042 (DebugReportFlagsEXT::DEBUG.0, "DEBUG"),
1043 ];
1044 debug_flags(f, KNOWN, self.0)
1045 }
1046}
1047impl fmt::Debug for DebugReportObjectTypeEXT {
1048 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1049 let name = match *self {
1050 Self::UNKNOWN => Some("UNKNOWN"),
1051 Self::INSTANCE => Some("INSTANCE"),
1052 Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"),
1053 Self::DEVICE => Some("DEVICE"),
1054 Self::QUEUE => Some("QUEUE"),
1055 Self::SEMAPHORE => Some("SEMAPHORE"),
1056 Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"),
1057 Self::FENCE => Some("FENCE"),
1058 Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"),
1059 Self::BUFFER => Some("BUFFER"),
1060 Self::IMAGE => Some("IMAGE"),
1061 Self::EVENT => Some("EVENT"),
1062 Self::QUERY_POOL => Some("QUERY_POOL"),
1063 Self::BUFFER_VIEW => Some("BUFFER_VIEW"),
1064 Self::IMAGE_VIEW => Some("IMAGE_VIEW"),
1065 Self::SHADER_MODULE => Some("SHADER_MODULE"),
1066 Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"),
1067 Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"),
1068 Self::RENDER_PASS => Some("RENDER_PASS"),
1069 Self::PIPELINE => Some("PIPELINE"),
1070 Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"),
1071 Self::SAMPLER => Some("SAMPLER"),
1072 Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"),
1073 Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"),
1074 Self::FRAMEBUFFER => Some("FRAMEBUFFER"),
1075 Self::COMMAND_POOL => Some("COMMAND_POOL"),
1076 Self::SURFACE_KHR => Some("SURFACE_KHR"),
1077 Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"),
1078 Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"),
1079 Self::DISPLAY_KHR => Some("DISPLAY_KHR"),
1080 Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"),
1081 Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"),
1082 Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"),
1083 Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"),
1084 Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"),
1085 Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"),
1086 Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
1087 Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
1088 Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"),
1089 _ => None,
1090 };
1091 if let Some(x) = name {
1092 f.write_str(x)
1093 } else {
1094 self.0.fmt(f)
1095 }
1096 }
1097}
1098impl fmt::Debug for DebugUtilsMessageSeverityFlagsEXT {
1099 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1100 const KNOWN: &[(Flags, &str)] = &[
1101 (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"),
1102 (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"),
1103 (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"),
1104 (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"),
1105 ];
1106 debug_flags(f, KNOWN, self.0)
1107 }
1108}
1109impl fmt::Debug for DebugUtilsMessageTypeFlagsEXT {
1110 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1111 const KNOWN: &[(Flags, &str)] = &[
1112 (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"),
1113 (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"),
1114 (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"),
1115 (
1116 DebugUtilsMessageTypeFlagsEXT::DEVICE_ADDRESS_BINDING.0,
1117 "DEVICE_ADDRESS_BINDING",
1118 ),
1119 ];
1120 debug_flags(f, KNOWN, self.0)
1121 }
1122}
1123impl fmt::Debug for DebugUtilsMessengerCallbackDataFlagsEXT {
1124 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1125 const KNOWN: &[(Flags, &str)] = &[];
1126 debug_flags(f, KNOWN, self.0)
1127 }
1128}
1129impl fmt::Debug for DebugUtilsMessengerCreateFlagsEXT {
1130 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1131 const KNOWN: &[(Flags, &str)] = &[];
1132 debug_flags(f, KNOWN, self.0)
1133 }
1134}
1135impl fmt::Debug for DependencyFlags {
1136 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1137 const KNOWN: &[(Flags, &str)] = &[
1138 (DependencyFlags::BY_REGION.0, "BY_REGION"),
1139 (DependencyFlags::FEEDBACK_LOOP_EXT.0, "FEEDBACK_LOOP_EXT"),
1140 (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"),
1141 (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"),
1142 ];
1143 debug_flags(f, KNOWN, self.0)
1144 }
1145}
1146impl fmt::Debug for DescriptorBindingFlags {
1147 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1148 const KNOWN: &[(Flags, &str)] = &[
1149 (
1150 DescriptorBindingFlags::UPDATE_AFTER_BIND.0,
1151 "UPDATE_AFTER_BIND",
1152 ),
1153 (
1154 DescriptorBindingFlags::UPDATE_UNUSED_WHILE_PENDING.0,
1155 "UPDATE_UNUSED_WHILE_PENDING",
1156 ),
1157 (DescriptorBindingFlags::PARTIALLY_BOUND.0, "PARTIALLY_BOUND"),
1158 (
1159 DescriptorBindingFlags::VARIABLE_DESCRIPTOR_COUNT.0,
1160 "VARIABLE_DESCRIPTOR_COUNT",
1161 ),
1162 (DescriptorBindingFlags::RESERVED_4_QCOM.0, "RESERVED_4_QCOM"),
1163 ];
1164 debug_flags(f, KNOWN, self.0)
1165 }
1166}
1167impl fmt::Debug for DescriptorPoolCreateFlags {
1168 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1169 const KNOWN: &[(Flags, &str)] = &[
1170 (
1171 DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0,
1172 "FREE_DESCRIPTOR_SET",
1173 ),
1174 (DescriptorPoolCreateFlags::HOST_ONLY_EXT.0, "HOST_ONLY_EXT"),
1175 (
1176 DescriptorPoolCreateFlags::UPDATE_AFTER_BIND.0,
1177 "UPDATE_AFTER_BIND",
1178 ),
1179 ];
1180 debug_flags(f, KNOWN, self.0)
1181 }
1182}
1183impl fmt::Debug for DescriptorPoolResetFlags {
1184 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1185 const KNOWN: &[(Flags, &str)] = &[];
1186 debug_flags(f, KNOWN, self.0)
1187 }
1188}
1189impl fmt::Debug for DescriptorSetLayoutCreateFlags {
1190 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1191 const KNOWN: &[(Flags, &str)] = &[
1192 (
1193 DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0,
1194 "PUSH_DESCRIPTOR_KHR",
1195 ),
1196 (
1197 DescriptorSetLayoutCreateFlags::DESCRIPTOR_BUFFER_EXT.0,
1198 "DESCRIPTOR_BUFFER_EXT",
1199 ),
1200 (
1201 DescriptorSetLayoutCreateFlags::EMBEDDED_IMMUTABLE_SAMPLERS_EXT.0,
1202 "EMBEDDED_IMMUTABLE_SAMPLERS_EXT",
1203 ),
1204 (
1205 DescriptorSetLayoutCreateFlags::RESERVED_3_AMD.0,
1206 "RESERVED_3_AMD",
1207 ),
1208 (
1209 DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_EXT.0,
1210 "HOST_ONLY_POOL_EXT",
1211 ),
1212 (
1213 DescriptorSetLayoutCreateFlags::RESERVED_6_EXT.0,
1214 "RESERVED_6_EXT",
1215 ),
1216 (
1217 DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL.0,
1218 "UPDATE_AFTER_BIND_POOL",
1219 ),
1220 ];
1221 debug_flags(f, KNOWN, self.0)
1222 }
1223}
1224impl fmt::Debug for DescriptorType {
1225 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1226 let name = match *self {
1227 Self::SAMPLER => Some("SAMPLER"),
1228 Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"),
1229 Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"),
1230 Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"),
1231 Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"),
1232 Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"),
1233 Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"),
1234 Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"),
1235 Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"),
1236 Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"),
1237 Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"),
1238 Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
1239 Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
1240 Self::SAMPLE_WEIGHT_IMAGE_QCOM => Some("SAMPLE_WEIGHT_IMAGE_QCOM"),
1241 Self::BLOCK_MATCH_IMAGE_QCOM => Some("BLOCK_MATCH_IMAGE_QCOM"),
1242 Self::MUTABLE_EXT => Some("MUTABLE_EXT"),
1243 Self::INLINE_UNIFORM_BLOCK => Some("INLINE_UNIFORM_BLOCK"),
1244 _ => None,
1245 };
1246 if let Some(x) = name {
1247 f.write_str(x)
1248 } else {
1249 self.0.fmt(f)
1250 }
1251 }
1252}
1253impl fmt::Debug for DescriptorUpdateTemplateCreateFlags {
1254 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1255 const KNOWN: &[(Flags, &str)] = &[];
1256 debug_flags(f, KNOWN, self.0)
1257 }
1258}
1259impl fmt::Debug for DescriptorUpdateTemplateType {
1260 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1261 let name = match *self {
1262 Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"),
1263 Self::PUSH_DESCRIPTORS_KHR => Some("PUSH_DESCRIPTORS_KHR"),
1264 _ => None,
1265 };
1266 if let Some(x) = name {
1267 f.write_str(x)
1268 } else {
1269 self.0.fmt(f)
1270 }
1271 }
1272}
1273impl fmt::Debug for DeviceAddressBindingFlagsEXT {
1274 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1275 const KNOWN: &[(Flags, &str)] = &[(
1276 DeviceAddressBindingFlagsEXT::INTERNAL_OBJECT.0,
1277 "INTERNAL_OBJECT",
1278 )];
1279 debug_flags(f, KNOWN, self.0)
1280 }
1281}
1282impl fmt::Debug for DeviceAddressBindingTypeEXT {
1283 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1284 let name = match *self {
1285 Self::BIND => Some("BIND"),
1286 Self::UNBIND => Some("UNBIND"),
1287 _ => None,
1288 };
1289 if let Some(x) = name {
1290 f.write_str(x)
1291 } else {
1292 self.0.fmt(f)
1293 }
1294 }
1295}
1296impl fmt::Debug for DeviceCreateFlags {
1297 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1298 const KNOWN: &[(Flags, &str)] = &[];
1299 debug_flags(f, KNOWN, self.0)
1300 }
1301}
1302impl fmt::Debug for DeviceDiagnosticsConfigFlagsNV {
1303 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1304 const KNOWN: &[(Flags, &str)] = &[
1305 (
1306 DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_DEBUG_INFO.0,
1307 "ENABLE_SHADER_DEBUG_INFO",
1308 ),
1309 (
1310 DeviceDiagnosticsConfigFlagsNV::ENABLE_RESOURCE_TRACKING.0,
1311 "ENABLE_RESOURCE_TRACKING",
1312 ),
1313 (
1314 DeviceDiagnosticsConfigFlagsNV::ENABLE_AUTOMATIC_CHECKPOINTS.0,
1315 "ENABLE_AUTOMATIC_CHECKPOINTS",
1316 ),
1317 (
1318 DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_ERROR_REPORTING.0,
1319 "ENABLE_SHADER_ERROR_REPORTING",
1320 ),
1321 ];
1322 debug_flags(f, KNOWN, self.0)
1323 }
1324}
1325impl fmt::Debug for DeviceEventTypeEXT {
1326 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1327 let name = match *self {
1328 Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"),
1329 _ => None,
1330 };
1331 if let Some(x) = name {
1332 f.write_str(x)
1333 } else {
1334 self.0.fmt(f)
1335 }
1336 }
1337}
1338impl fmt::Debug for DeviceFaultAddressTypeEXT {
1339 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1340 let name = match *self {
1341 Self::NONE => Some("NONE"),
1342 Self::READ_INVALID => Some("READ_INVALID"),
1343 Self::WRITE_INVALID => Some("WRITE_INVALID"),
1344 Self::EXECUTE_INVALID => Some("EXECUTE_INVALID"),
1345 Self::INSTRUCTION_POINTER_UNKNOWN => Some("INSTRUCTION_POINTER_UNKNOWN"),
1346 Self::INSTRUCTION_POINTER_INVALID => Some("INSTRUCTION_POINTER_INVALID"),
1347 Self::INSTRUCTION_POINTER_FAULT => Some("INSTRUCTION_POINTER_FAULT"),
1348 _ => None,
1349 };
1350 if let Some(x) = name {
1351 f.write_str(x)
1352 } else {
1353 self.0.fmt(f)
1354 }
1355 }
1356}
1357impl fmt::Debug for DeviceFaultVendorBinaryHeaderVersionEXT {
1358 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1359 let name = match *self {
1360 Self::ONE => Some("ONE"),
1361 _ => None,
1362 };
1363 if let Some(x) = name {
1364 f.write_str(x)
1365 } else {
1366 self.0.fmt(f)
1367 }
1368 }
1369}
1370impl fmt::Debug for DeviceGroupPresentModeFlagsKHR {
1371 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1372 const KNOWN: &[(Flags, &str)] = &[
1373 (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"),
1374 (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"),
1375 (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"),
1376 (
1377 DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0,
1378 "LOCAL_MULTI_DEVICE",
1379 ),
1380 ];
1381 debug_flags(f, KNOWN, self.0)
1382 }
1383}
1384impl fmt::Debug for DeviceMemoryReportEventTypeEXT {
1385 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1386 let name = match *self {
1387 Self::ALLOCATE => Some("ALLOCATE"),
1388 Self::FREE => Some("FREE"),
1389 Self::IMPORT => Some("IMPORT"),
1390 Self::UNIMPORT => Some("UNIMPORT"),
1391 Self::ALLOCATION_FAILED => Some("ALLOCATION_FAILED"),
1392 _ => None,
1393 };
1394 if let Some(x) = name {
1395 f.write_str(x)
1396 } else {
1397 self.0.fmt(f)
1398 }
1399 }
1400}
1401impl fmt::Debug for DeviceMemoryReportFlagsEXT {
1402 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1403 const KNOWN: &[(Flags, &str)] = &[];
1404 debug_flags(f, KNOWN, self.0)
1405 }
1406}
1407impl fmt::Debug for DeviceQueueCreateFlags {
1408 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1409 const KNOWN: &[(Flags, &str)] = &[
1410 (DeviceQueueCreateFlags::RESERVED_1_QCOM.0, "RESERVED_1_QCOM"),
1411 (DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED"),
1412 ];
1413 debug_flags(f, KNOWN, self.0)
1414 }
1415}
1416impl fmt::Debug for DirectDriverLoadingFlagsLUNARG {
1417 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1418 const KNOWN: &[(Flags, &str)] = &[];
1419 debug_flags(f, KNOWN, self.0)
1420 }
1421}
1422impl fmt::Debug for DirectDriverLoadingModeLUNARG {
1423 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1424 let name = match *self {
1425 Self::EXCLUSIVE => Some("EXCLUSIVE"),
1426 Self::INCLUSIVE => Some("INCLUSIVE"),
1427 _ => None,
1428 };
1429 if let Some(x) = name {
1430 f.write_str(x)
1431 } else {
1432 self.0.fmt(f)
1433 }
1434 }
1435}
1436impl fmt::Debug for DirectFBSurfaceCreateFlagsEXT {
1437 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1438 const KNOWN: &[(Flags, &str)] = &[];
1439 debug_flags(f, KNOWN, self.0)
1440 }
1441}
1442impl fmt::Debug for DiscardRectangleModeEXT {
1443 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1444 let name = match *self {
1445 Self::INCLUSIVE => Some("INCLUSIVE"),
1446 Self::EXCLUSIVE => Some("EXCLUSIVE"),
1447 _ => None,
1448 };
1449 if let Some(x) = name {
1450 f.write_str(x)
1451 } else {
1452 self.0.fmt(f)
1453 }
1454 }
1455}
1456impl fmt::Debug for DisplacementMicromapFormatNV {
1457 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1458 let name = match *self {
1459 Self::TYPE_64_TRIANGLES_64_BYTES => Some("TYPE_64_TRIANGLES_64_BYTES"),
1460 Self::TYPE_256_TRIANGLES_128_BYTES => Some("TYPE_256_TRIANGLES_128_BYTES"),
1461 Self::TYPE_1024_TRIANGLES_128_BYTES => Some("TYPE_1024_TRIANGLES_128_BYTES"),
1462 _ => None,
1463 };
1464 if let Some(x) = name {
1465 f.write_str(x)
1466 } else {
1467 self.0.fmt(f)
1468 }
1469 }
1470}
1471impl fmt::Debug for DisplayEventTypeEXT {
1472 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1473 let name = match *self {
1474 Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"),
1475 _ => None,
1476 };
1477 if let Some(x) = name {
1478 f.write_str(x)
1479 } else {
1480 self.0.fmt(f)
1481 }
1482 }
1483}
1484impl fmt::Debug for DisplayModeCreateFlagsKHR {
1485 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1486 const KNOWN: &[(Flags, &str)] = &[];
1487 debug_flags(f, KNOWN, self.0)
1488 }
1489}
1490impl fmt::Debug for DisplayPlaneAlphaFlagsKHR {
1491 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1492 const KNOWN: &[(Flags, &str)] = &[
1493 (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"),
1494 (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"),
1495 (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"),
1496 (
1497 DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0,
1498 "PER_PIXEL_PREMULTIPLIED",
1499 ),
1500 ];
1501 debug_flags(f, KNOWN, self.0)
1502 }
1503}
1504impl fmt::Debug for DisplayPowerStateEXT {
1505 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1506 let name = match *self {
1507 Self::OFF => Some("OFF"),
1508 Self::SUSPEND => Some("SUSPEND"),
1509 Self::ON => Some("ON"),
1510 _ => None,
1511 };
1512 if let Some(x) = name {
1513 f.write_str(x)
1514 } else {
1515 self.0.fmt(f)
1516 }
1517 }
1518}
1519impl fmt::Debug for DisplaySurfaceCreateFlagsKHR {
1520 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1521 const KNOWN: &[(Flags, &str)] = &[];
1522 debug_flags(f, KNOWN, self.0)
1523 }
1524}
1525impl fmt::Debug for DriverId {
1526 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1527 let name = match *self {
1528 Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"),
1529 Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"),
1530 Self::MESA_RADV => Some("MESA_RADV"),
1531 Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"),
1532 Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"),
1533 Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"),
1534 Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"),
1535 Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"),
1536 Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"),
1537 Self::GOOGLE_SWIFTSHADER => Some("GOOGLE_SWIFTSHADER"),
1538 Self::GGP_PROPRIETARY => Some("GGP_PROPRIETARY"),
1539 Self::BROADCOM_PROPRIETARY => Some("BROADCOM_PROPRIETARY"),
1540 Self::MESA_LLVMPIPE => Some("MESA_LLVMPIPE"),
1541 Self::MOLTENVK => Some("MOLTENVK"),
1542 Self::COREAVI_PROPRIETARY => Some("COREAVI_PROPRIETARY"),
1543 Self::JUICE_PROPRIETARY => Some("JUICE_PROPRIETARY"),
1544 Self::VERISILICON_PROPRIETARY => Some("VERISILICON_PROPRIETARY"),
1545 Self::MESA_TURNIP => Some("MESA_TURNIP"),
1546 Self::MESA_V3DV => Some("MESA_V3DV"),
1547 Self::MESA_PANVK => Some("MESA_PANVK"),
1548 Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"),
1549 Self::MESA_VENUS => Some("MESA_VENUS"),
1550 Self::MESA_DOZEN => Some("MESA_DOZEN"),
1551 Self::MESA_NVK => Some("MESA_NVK"),
1552 Self::IMAGINATION_OPEN_SOURCE_MESA => Some("IMAGINATION_OPEN_SOURCE_MESA"),
1553 _ => None,
1554 };
1555 if let Some(x) = name {
1556 f.write_str(x)
1557 } else {
1558 self.0.fmt(f)
1559 }
1560 }
1561}
1562impl fmt::Debug for DynamicState {
1563 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1564 let name = match *self {
1565 Self::VIEWPORT => Some("VIEWPORT"),
1566 Self::SCISSOR => Some("SCISSOR"),
1567 Self::LINE_WIDTH => Some("LINE_WIDTH"),
1568 Self::DEPTH_BIAS => Some("DEPTH_BIAS"),
1569 Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"),
1570 Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"),
1571 Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"),
1572 Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"),
1573 Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"),
1574 Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"),
1575 Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"),
1576 Self::DISCARD_RECTANGLE_ENABLE_EXT => Some("DISCARD_RECTANGLE_ENABLE_EXT"),
1577 Self::DISCARD_RECTANGLE_MODE_EXT => Some("DISCARD_RECTANGLE_MODE_EXT"),
1578 Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"),
1579 Self::RAY_TRACING_PIPELINE_STACK_SIZE_KHR => {
1580 Some("RAY_TRACING_PIPELINE_STACK_SIZE_KHR")
1581 }
1582 Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"),
1583 Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"),
1584 Self::EXCLUSIVE_SCISSOR_ENABLE_NV => Some("EXCLUSIVE_SCISSOR_ENABLE_NV"),
1585 Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"),
1586 Self::FRAGMENT_SHADING_RATE_KHR => Some("FRAGMENT_SHADING_RATE_KHR"),
1587 Self::LINE_STIPPLE_EXT => Some("LINE_STIPPLE_EXT"),
1588 Self::VERTEX_INPUT_EXT => Some("VERTEX_INPUT_EXT"),
1589 Self::PATCH_CONTROL_POINTS_EXT => Some("PATCH_CONTROL_POINTS_EXT"),
1590 Self::LOGIC_OP_EXT => Some("LOGIC_OP_EXT"),
1591 Self::COLOR_WRITE_ENABLE_EXT => Some("COLOR_WRITE_ENABLE_EXT"),
1592 Self::TESSELLATION_DOMAIN_ORIGIN_EXT => Some("TESSELLATION_DOMAIN_ORIGIN_EXT"),
1593 Self::DEPTH_CLAMP_ENABLE_EXT => Some("DEPTH_CLAMP_ENABLE_EXT"),
1594 Self::POLYGON_MODE_EXT => Some("POLYGON_MODE_EXT"),
1595 Self::RASTERIZATION_SAMPLES_EXT => Some("RASTERIZATION_SAMPLES_EXT"),
1596 Self::SAMPLE_MASK_EXT => Some("SAMPLE_MASK_EXT"),
1597 Self::ALPHA_TO_COVERAGE_ENABLE_EXT => Some("ALPHA_TO_COVERAGE_ENABLE_EXT"),
1598 Self::ALPHA_TO_ONE_ENABLE_EXT => Some("ALPHA_TO_ONE_ENABLE_EXT"),
1599 Self::LOGIC_OP_ENABLE_EXT => Some("LOGIC_OP_ENABLE_EXT"),
1600 Self::COLOR_BLEND_ENABLE_EXT => Some("COLOR_BLEND_ENABLE_EXT"),
1601 Self::COLOR_BLEND_EQUATION_EXT => Some("COLOR_BLEND_EQUATION_EXT"),
1602 Self::COLOR_WRITE_MASK_EXT => Some("COLOR_WRITE_MASK_EXT"),
1603 Self::RASTERIZATION_STREAM_EXT => Some("RASTERIZATION_STREAM_EXT"),
1604 Self::CONSERVATIVE_RASTERIZATION_MODE_EXT => {
1605 Some("CONSERVATIVE_RASTERIZATION_MODE_EXT")
1606 }
1607 Self::EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT => {
1608 Some("EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT")
1609 }
1610 Self::DEPTH_CLIP_ENABLE_EXT => Some("DEPTH_CLIP_ENABLE_EXT"),
1611 Self::SAMPLE_LOCATIONS_ENABLE_EXT => Some("SAMPLE_LOCATIONS_ENABLE_EXT"),
1612 Self::COLOR_BLEND_ADVANCED_EXT => Some("COLOR_BLEND_ADVANCED_EXT"),
1613 Self::PROVOKING_VERTEX_MODE_EXT => Some("PROVOKING_VERTEX_MODE_EXT"),
1614 Self::LINE_RASTERIZATION_MODE_EXT => Some("LINE_RASTERIZATION_MODE_EXT"),
1615 Self::LINE_STIPPLE_ENABLE_EXT => Some("LINE_STIPPLE_ENABLE_EXT"),
1616 Self::DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT => Some("DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT"),
1617 Self::VIEWPORT_W_SCALING_ENABLE_NV => Some("VIEWPORT_W_SCALING_ENABLE_NV"),
1618 Self::VIEWPORT_SWIZZLE_NV => Some("VIEWPORT_SWIZZLE_NV"),
1619 Self::COVERAGE_TO_COLOR_ENABLE_NV => Some("COVERAGE_TO_COLOR_ENABLE_NV"),
1620 Self::COVERAGE_TO_COLOR_LOCATION_NV => Some("COVERAGE_TO_COLOR_LOCATION_NV"),
1621 Self::COVERAGE_MODULATION_MODE_NV => Some("COVERAGE_MODULATION_MODE_NV"),
1622 Self::COVERAGE_MODULATION_TABLE_ENABLE_NV => {
1623 Some("COVERAGE_MODULATION_TABLE_ENABLE_NV")
1624 }
1625 Self::COVERAGE_MODULATION_TABLE_NV => Some("COVERAGE_MODULATION_TABLE_NV"),
1626 Self::SHADING_RATE_IMAGE_ENABLE_NV => Some("SHADING_RATE_IMAGE_ENABLE_NV"),
1627 Self::REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV => {
1628 Some("REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV")
1629 }
1630 Self::COVERAGE_REDUCTION_MODE_NV => Some("COVERAGE_REDUCTION_MODE_NV"),
1631 Self::ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT => {
1632 Some("ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT")
1633 }
1634 Self::CULL_MODE => Some("CULL_MODE"),
1635 Self::FRONT_FACE => Some("FRONT_FACE"),
1636 Self::PRIMITIVE_TOPOLOGY => Some("PRIMITIVE_TOPOLOGY"),
1637 Self::VIEWPORT_WITH_COUNT => Some("VIEWPORT_WITH_COUNT"),
1638 Self::SCISSOR_WITH_COUNT => Some("SCISSOR_WITH_COUNT"),
1639 Self::VERTEX_INPUT_BINDING_STRIDE => Some("VERTEX_INPUT_BINDING_STRIDE"),
1640 Self::DEPTH_TEST_ENABLE => Some("DEPTH_TEST_ENABLE"),
1641 Self::DEPTH_WRITE_ENABLE => Some("DEPTH_WRITE_ENABLE"),
1642 Self::DEPTH_COMPARE_OP => Some("DEPTH_COMPARE_OP"),
1643 Self::DEPTH_BOUNDS_TEST_ENABLE => Some("DEPTH_BOUNDS_TEST_ENABLE"),
1644 Self::STENCIL_TEST_ENABLE => Some("STENCIL_TEST_ENABLE"),
1645 Self::STENCIL_OP => Some("STENCIL_OP"),
1646 Self::RASTERIZER_DISCARD_ENABLE => Some("RASTERIZER_DISCARD_ENABLE"),
1647 Self::DEPTH_BIAS_ENABLE => Some("DEPTH_BIAS_ENABLE"),
1648 Self::PRIMITIVE_RESTART_ENABLE => Some("PRIMITIVE_RESTART_ENABLE"),
1649 _ => None,
1650 };
1651 if let Some(x) = name {
1652 f.write_str(x)
1653 } else {
1654 self.0.fmt(f)
1655 }
1656 }
1657}
1658impl fmt::Debug for EventCreateFlags {
1659 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1660 const KNOWN: &[(Flags, &str)] = &[(EventCreateFlags::DEVICE_ONLY.0, "DEVICE_ONLY")];
1661 debug_flags(f, KNOWN, self.0)
1662 }
1663}
1664impl fmt::Debug for ExportMetalObjectTypeFlagsEXT {
1665 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1666 const KNOWN: &[(Flags, &str)] = &[
1667 (
1668 ExportMetalObjectTypeFlagsEXT::METAL_DEVICE.0,
1669 "METAL_DEVICE",
1670 ),
1671 (
1672 ExportMetalObjectTypeFlagsEXT::METAL_COMMAND_QUEUE.0,
1673 "METAL_COMMAND_QUEUE",
1674 ),
1675 (
1676 ExportMetalObjectTypeFlagsEXT::METAL_BUFFER.0,
1677 "METAL_BUFFER",
1678 ),
1679 (
1680 ExportMetalObjectTypeFlagsEXT::METAL_TEXTURE.0,
1681 "METAL_TEXTURE",
1682 ),
1683 (
1684 ExportMetalObjectTypeFlagsEXT::METAL_IOSURFACE.0,
1685 "METAL_IOSURFACE",
1686 ),
1687 (
1688 ExportMetalObjectTypeFlagsEXT::METAL_SHARED_EVENT.0,
1689 "METAL_SHARED_EVENT",
1690 ),
1691 ];
1692 debug_flags(f, KNOWN, self.0)
1693 }
1694}
1695impl fmt::Debug for ExternalFenceFeatureFlags {
1696 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1697 const KNOWN: &[(Flags, &str)] = &[
1698 (ExternalFenceFeatureFlags::EXPORTABLE.0, "EXPORTABLE"),
1699 (ExternalFenceFeatureFlags::IMPORTABLE.0, "IMPORTABLE"),
1700 ];
1701 debug_flags(f, KNOWN, self.0)
1702 }
1703}
1704impl fmt::Debug for ExternalFenceHandleTypeFlags {
1705 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1706 const KNOWN: &[(Flags, &str)] = &[
1707 (ExternalFenceHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"),
1708 (ExternalFenceHandleTypeFlags::OPAQUE_WIN32.0, "OPAQUE_WIN32"),
1709 (
1710 ExternalFenceHandleTypeFlags::OPAQUE_WIN32_KMT.0,
1711 "OPAQUE_WIN32_KMT",
1712 ),
1713 (ExternalFenceHandleTypeFlags::SYNC_FD.0, "SYNC_FD"),
1714 ];
1715 debug_flags(f, KNOWN, self.0)
1716 }
1717}
1718impl fmt::Debug for ExternalMemoryFeatureFlags {
1719 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1720 const KNOWN: &[(Flags, &str)] = &[
1721 (
1722 ExternalMemoryFeatureFlags::DEDICATED_ONLY.0,
1723 "DEDICATED_ONLY",
1724 ),
1725 (ExternalMemoryFeatureFlags::EXPORTABLE.0, "EXPORTABLE"),
1726 (ExternalMemoryFeatureFlags::IMPORTABLE.0, "IMPORTABLE"),
1727 ];
1728 debug_flags(f, KNOWN, self.0)
1729 }
1730}
1731impl fmt::Debug for ExternalMemoryFeatureFlagsNV {
1732 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1733 const KNOWN: &[(Flags, &str)] = &[
1734 (
1735 ExternalMemoryFeatureFlagsNV::DEDICATED_ONLY.0,
1736 "DEDICATED_ONLY",
1737 ),
1738 (ExternalMemoryFeatureFlagsNV::EXPORTABLE.0, "EXPORTABLE"),
1739 (ExternalMemoryFeatureFlagsNV::IMPORTABLE.0, "IMPORTABLE"),
1740 ];
1741 debug_flags(f, KNOWN, self.0)
1742 }
1743}
1744impl fmt::Debug for ExternalMemoryHandleTypeFlags {
1745 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1746 const KNOWN: &[(Flags, &str)] = &[
1747 (ExternalMemoryHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"),
1748 (
1749 ExternalMemoryHandleTypeFlags::OPAQUE_WIN32.0,
1750 "OPAQUE_WIN32",
1751 ),
1752 (
1753 ExternalMemoryHandleTypeFlags::OPAQUE_WIN32_KMT.0,
1754 "OPAQUE_WIN32_KMT",
1755 ),
1756 (
1757 ExternalMemoryHandleTypeFlags::D3D11_TEXTURE.0,
1758 "D3D11_TEXTURE",
1759 ),
1760 (
1761 ExternalMemoryHandleTypeFlags::D3D11_TEXTURE_KMT.0,
1762 "D3D11_TEXTURE_KMT",
1763 ),
1764 (ExternalMemoryHandleTypeFlags::D3D12_HEAP.0, "D3D12_HEAP"),
1765 (
1766 ExternalMemoryHandleTypeFlags::D3D12_RESOURCE.0,
1767 "D3D12_RESOURCE",
1768 ),
1769 (ExternalMemoryHandleTypeFlags::DMA_BUF_EXT.0, "DMA_BUF_EXT"),
1770 (
1771 ExternalMemoryHandleTypeFlags::ANDROID_HARDWARE_BUFFER_ANDROID.0,
1772 "ANDROID_HARDWARE_BUFFER_ANDROID",
1773 ),
1774 (
1775 ExternalMemoryHandleTypeFlags::HOST_ALLOCATION_EXT.0,
1776 "HOST_ALLOCATION_EXT",
1777 ),
1778 (
1779 ExternalMemoryHandleTypeFlags::HOST_MAPPED_FOREIGN_MEMORY_EXT.0,
1780 "HOST_MAPPED_FOREIGN_MEMORY_EXT",
1781 ),
1782 (
1783 ExternalMemoryHandleTypeFlags::ZIRCON_VMO_FUCHSIA.0,
1784 "ZIRCON_VMO_FUCHSIA",
1785 ),
1786 (
1787 ExternalMemoryHandleTypeFlags::RDMA_ADDRESS_NV.0,
1788 "RDMA_ADDRESS_NV",
1789 ),
1790 (
1791 ExternalMemoryHandleTypeFlags::TYPE_530_QNX.0,
1792 "TYPE_530_QNX",
1793 ),
1794 ];
1795 debug_flags(f, KNOWN, self.0)
1796 }
1797}
1798impl fmt::Debug for ExternalMemoryHandleTypeFlagsNV {
1799 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1800 const KNOWN: &[(Flags, &str)] = &[
1801 (
1802 ExternalMemoryHandleTypeFlagsNV::OPAQUE_WIN32.0,
1803 "OPAQUE_WIN32",
1804 ),
1805 (
1806 ExternalMemoryHandleTypeFlagsNV::OPAQUE_WIN32_KMT.0,
1807 "OPAQUE_WIN32_KMT",
1808 ),
1809 (
1810 ExternalMemoryHandleTypeFlagsNV::D3D11_IMAGE.0,
1811 "D3D11_IMAGE",
1812 ),
1813 (
1814 ExternalMemoryHandleTypeFlagsNV::D3D11_IMAGE_KMT.0,
1815 "D3D11_IMAGE_KMT",
1816 ),
1817 ];
1818 debug_flags(f, KNOWN, self.0)
1819 }
1820}
1821impl fmt::Debug for ExternalSemaphoreFeatureFlags {
1822 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1823 const KNOWN: &[(Flags, &str)] = &[
1824 (ExternalSemaphoreFeatureFlags::EXPORTABLE.0, "EXPORTABLE"),
1825 (ExternalSemaphoreFeatureFlags::IMPORTABLE.0, "IMPORTABLE"),
1826 ];
1827 debug_flags(f, KNOWN, self.0)
1828 }
1829}
1830impl fmt::Debug for ExternalSemaphoreHandleTypeFlags {
1831 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1832 const KNOWN: &[(Flags, &str)] = &[
1833 (ExternalSemaphoreHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"),
1834 (
1835 ExternalSemaphoreHandleTypeFlags::OPAQUE_WIN32.0,
1836 "OPAQUE_WIN32",
1837 ),
1838 (
1839 ExternalSemaphoreHandleTypeFlags::OPAQUE_WIN32_KMT.0,
1840 "OPAQUE_WIN32_KMT",
1841 ),
1842 (
1843 ExternalSemaphoreHandleTypeFlags::D3D12_FENCE.0,
1844 "D3D12_FENCE",
1845 ),
1846 (ExternalSemaphoreHandleTypeFlags::SYNC_FD.0, "SYNC_FD"),
1847 (
1848 ExternalSemaphoreHandleTypeFlags::ZIRCON_EVENT_FUCHSIA.0,
1849 "ZIRCON_EVENT_FUCHSIA",
1850 ),
1851 ];
1852 debug_flags(f, KNOWN, self.0)
1853 }
1854}
1855impl fmt::Debug for FenceCreateFlags {
1856 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1857 const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")];
1858 debug_flags(f, KNOWN, self.0)
1859 }
1860}
1861impl fmt::Debug for FenceImportFlags {
1862 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1863 const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")];
1864 debug_flags(f, KNOWN, self.0)
1865 }
1866}
1867impl fmt::Debug for Filter {
1868 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1869 let name = match *self {
1870 Self::NEAREST => Some("NEAREST"),
1871 Self::LINEAR => Some("LINEAR"),
1872 Self::CUBIC_EXT => Some("CUBIC_EXT"),
1873 _ => None,
1874 };
1875 if let Some(x) = name {
1876 f.write_str(x)
1877 } else {
1878 self.0.fmt(f)
1879 }
1880 }
1881}
1882impl fmt::Debug for Format {
1883 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1884 let name = match *self {
1885 Self::UNDEFINED => Some("UNDEFINED"),
1886 Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"),
1887 Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"),
1888 Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"),
1889 Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"),
1890 Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"),
1891 Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"),
1892 Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"),
1893 Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"),
1894 Self::R8_UNORM => Some("R8_UNORM"),
1895 Self::R8_SNORM => Some("R8_SNORM"),
1896 Self::R8_USCALED => Some("R8_USCALED"),
1897 Self::R8_SSCALED => Some("R8_SSCALED"),
1898 Self::R8_UINT => Some("R8_UINT"),
1899 Self::R8_SINT => Some("R8_SINT"),
1900 Self::R8_SRGB => Some("R8_SRGB"),
1901 Self::R8G8_UNORM => Some("R8G8_UNORM"),
1902 Self::R8G8_SNORM => Some("R8G8_SNORM"),
1903 Self::R8G8_USCALED => Some("R8G8_USCALED"),
1904 Self::R8G8_SSCALED => Some("R8G8_SSCALED"),
1905 Self::R8G8_UINT => Some("R8G8_UINT"),
1906 Self::R8G8_SINT => Some("R8G8_SINT"),
1907 Self::R8G8_SRGB => Some("R8G8_SRGB"),
1908 Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"),
1909 Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"),
1910 Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"),
1911 Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"),
1912 Self::R8G8B8_UINT => Some("R8G8B8_UINT"),
1913 Self::R8G8B8_SINT => Some("R8G8B8_SINT"),
1914 Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"),
1915 Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"),
1916 Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"),
1917 Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"),
1918 Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"),
1919 Self::B8G8R8_UINT => Some("B8G8R8_UINT"),
1920 Self::B8G8R8_SINT => Some("B8G8R8_SINT"),
1921 Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"),
1922 Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"),
1923 Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"),
1924 Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"),
1925 Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"),
1926 Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"),
1927 Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"),
1928 Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"),
1929 Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"),
1930 Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"),
1931 Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"),
1932 Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"),
1933 Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"),
1934 Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"),
1935 Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"),
1936 Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"),
1937 Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"),
1938 Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"),
1939 Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"),
1940 Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"),
1941 Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"),
1942 Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"),
1943 Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"),
1944 Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"),
1945 Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"),
1946 Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"),
1947 Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"),
1948 Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"),
1949 Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"),
1950 Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"),
1951 Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"),
1952 Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"),
1953 Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"),
1954 Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"),
1955 Self::R16_UNORM => Some("R16_UNORM"),
1956 Self::R16_SNORM => Some("R16_SNORM"),
1957 Self::R16_USCALED => Some("R16_USCALED"),
1958 Self::R16_SSCALED => Some("R16_SSCALED"),
1959 Self::R16_UINT => Some("R16_UINT"),
1960 Self::R16_SINT => Some("R16_SINT"),
1961 Self::R16_SFLOAT => Some("R16_SFLOAT"),
1962 Self::R16G16_UNORM => Some("R16G16_UNORM"),
1963 Self::R16G16_SNORM => Some("R16G16_SNORM"),
1964 Self::R16G16_USCALED => Some("R16G16_USCALED"),
1965 Self::R16G16_SSCALED => Some("R16G16_SSCALED"),
1966 Self::R16G16_UINT => Some("R16G16_UINT"),
1967 Self::R16G16_SINT => Some("R16G16_SINT"),
1968 Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"),
1969 Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"),
1970 Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"),
1971 Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"),
1972 Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"),
1973 Self::R16G16B16_UINT => Some("R16G16B16_UINT"),
1974 Self::R16G16B16_SINT => Some("R16G16B16_SINT"),
1975 Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"),
1976 Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"),
1977 Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"),
1978 Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"),
1979 Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"),
1980 Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"),
1981 Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"),
1982 Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"),
1983 Self::R32_UINT => Some("R32_UINT"),
1984 Self::R32_SINT => Some("R32_SINT"),
1985 Self::R32_SFLOAT => Some("R32_SFLOAT"),
1986 Self::R32G32_UINT => Some("R32G32_UINT"),
1987 Self::R32G32_SINT => Some("R32G32_SINT"),
1988 Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"),
1989 Self::R32G32B32_UINT => Some("R32G32B32_UINT"),
1990 Self::R32G32B32_SINT => Some("R32G32B32_SINT"),
1991 Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"),
1992 Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"),
1993 Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"),
1994 Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"),
1995 Self::R64_UINT => Some("R64_UINT"),
1996 Self::R64_SINT => Some("R64_SINT"),
1997 Self::R64_SFLOAT => Some("R64_SFLOAT"),
1998 Self::R64G64_UINT => Some("R64G64_UINT"),
1999 Self::R64G64_SINT => Some("R64G64_SINT"),
2000 Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"),
2001 Self::R64G64B64_UINT => Some("R64G64B64_UINT"),
2002 Self::R64G64B64_SINT => Some("R64G64B64_SINT"),
2003 Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"),
2004 Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"),
2005 Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"),
2006 Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"),
2007 Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"),
2008 Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"),
2009 Self::D16_UNORM => Some("D16_UNORM"),
2010 Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"),
2011 Self::D32_SFLOAT => Some("D32_SFLOAT"),
2012 Self::S8_UINT => Some("S8_UINT"),
2013 Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"),
2014 Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"),
2015 Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"),
2016 Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"),
2017 Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"),
2018 Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"),
2019 Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"),
2020 Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"),
2021 Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"),
2022 Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"),
2023 Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"),
2024 Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"),
2025 Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"),
2026 Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"),
2027 Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"),
2028 Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"),
2029 Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"),
2030 Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"),
2031 Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"),
2032 Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"),
2033 Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"),
2034 Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"),
2035 Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"),
2036 Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"),
2037 Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"),
2038 Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"),
2039 Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"),
2040 Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"),
2041 Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"),
2042 Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"),
2043 Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"),
2044 Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"),
2045 Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"),
2046 Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"),
2047 Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"),
2048 Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"),
2049 Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"),
2050 Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"),
2051 Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"),
2052 Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"),
2053 Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"),
2054 Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"),
2055 Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"),
2056 Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"),
2057 Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"),
2058 Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"),
2059 Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"),
2060 Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"),
2061 Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"),
2062 Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"),
2063 Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"),
2064 Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"),
2065 Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"),
2066 Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"),
2067 Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"),
2068 Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"),
2069 Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"),
2070 Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"),
2071 Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"),
2072 Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"),
2073 Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"),
2074 Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"),
2075 Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"),
2076 Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"),
2077 Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"),
2078 Self::ASTC_3X3X3_UNORM_BLOCK_EXT => Some("ASTC_3X3X3_UNORM_BLOCK_EXT"),
2079 Self::ASTC_3X3X3_SRGB_BLOCK_EXT => Some("ASTC_3X3X3_SRGB_BLOCK_EXT"),
2080 Self::ASTC_3X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_3X3X3_SFLOAT_BLOCK_EXT"),
2081 Self::ASTC_4X3X3_UNORM_BLOCK_EXT => Some("ASTC_4X3X3_UNORM_BLOCK_EXT"),
2082 Self::ASTC_4X3X3_SRGB_BLOCK_EXT => Some("ASTC_4X3X3_SRGB_BLOCK_EXT"),
2083 Self::ASTC_4X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X3X3_SFLOAT_BLOCK_EXT"),
2084 Self::ASTC_4X4X3_UNORM_BLOCK_EXT => Some("ASTC_4X4X3_UNORM_BLOCK_EXT"),
2085 Self::ASTC_4X4X3_SRGB_BLOCK_EXT => Some("ASTC_4X4X3_SRGB_BLOCK_EXT"),
2086 Self::ASTC_4X4X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X3_SFLOAT_BLOCK_EXT"),
2087 Self::ASTC_4X4X4_UNORM_BLOCK_EXT => Some("ASTC_4X4X4_UNORM_BLOCK_EXT"),
2088 Self::ASTC_4X4X4_SRGB_BLOCK_EXT => Some("ASTC_4X4X4_SRGB_BLOCK_EXT"),
2089 Self::ASTC_4X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X4_SFLOAT_BLOCK_EXT"),
2090 Self::ASTC_5X4X4_UNORM_BLOCK_EXT => Some("ASTC_5X4X4_UNORM_BLOCK_EXT"),
2091 Self::ASTC_5X4X4_SRGB_BLOCK_EXT => Some("ASTC_5X4X4_SRGB_BLOCK_EXT"),
2092 Self::ASTC_5X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X4X4_SFLOAT_BLOCK_EXT"),
2093 Self::ASTC_5X5X4_UNORM_BLOCK_EXT => Some("ASTC_5X5X4_UNORM_BLOCK_EXT"),
2094 Self::ASTC_5X5X4_SRGB_BLOCK_EXT => Some("ASTC_5X5X4_SRGB_BLOCK_EXT"),
2095 Self::ASTC_5X5X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X4_SFLOAT_BLOCK_EXT"),
2096 Self::ASTC_5X5X5_UNORM_BLOCK_EXT => Some("ASTC_5X5X5_UNORM_BLOCK_EXT"),
2097 Self::ASTC_5X5X5_SRGB_BLOCK_EXT => Some("ASTC_5X5X5_SRGB_BLOCK_EXT"),
2098 Self::ASTC_5X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X5_SFLOAT_BLOCK_EXT"),
2099 Self::ASTC_6X5X5_UNORM_BLOCK_EXT => Some("ASTC_6X5X5_UNORM_BLOCK_EXT"),
2100 Self::ASTC_6X5X5_SRGB_BLOCK_EXT => Some("ASTC_6X5X5_SRGB_BLOCK_EXT"),
2101 Self::ASTC_6X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X5X5_SFLOAT_BLOCK_EXT"),
2102 Self::ASTC_6X6X5_UNORM_BLOCK_EXT => Some("ASTC_6X6X5_UNORM_BLOCK_EXT"),
2103 Self::ASTC_6X6X5_SRGB_BLOCK_EXT => Some("ASTC_6X6X5_SRGB_BLOCK_EXT"),
2104 Self::ASTC_6X6X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X5_SFLOAT_BLOCK_EXT"),
2105 Self::ASTC_6X6X6_UNORM_BLOCK_EXT => Some("ASTC_6X6X6_UNORM_BLOCK_EXT"),
2106 Self::ASTC_6X6X6_SRGB_BLOCK_EXT => Some("ASTC_6X6X6_SRGB_BLOCK_EXT"),
2107 Self::ASTC_6X6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X6_SFLOAT_BLOCK_EXT"),
2108 Self::R16G16_S10_5_NV => Some("R16G16_S10_5_NV"),
2109 Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"),
2110 Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"),
2111 Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"),
2112 Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"),
2113 Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"),
2114 Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"),
2115 Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"),
2116 Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"),
2117 Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"),
2118 Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"),
2119 Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => {
2120 Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16")
2121 }
2122 Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => {
2123 Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16")
2124 }
2125 Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => {
2126 Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16")
2127 }
2128 Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => {
2129 Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16")
2130 }
2131 Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => {
2132 Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16")
2133 }
2134 Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => {
2135 Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16")
2136 }
2137 Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => {
2138 Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16")
2139 }
2140 Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"),
2141 Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"),
2142 Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"),
2143 Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => {
2144 Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16")
2145 }
2146 Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => {
2147 Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16")
2148 }
2149 Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => {
2150 Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16")
2151 }
2152 Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => {
2153 Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16")
2154 }
2155 Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => {
2156 Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16")
2157 }
2158 Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => {
2159 Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16")
2160 }
2161 Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => {
2162 Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16")
2163 }
2164 Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"),
2165 Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"),
2166 Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"),
2167 Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"),
2168 Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"),
2169 Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"),
2170 Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"),
2171 Self::G8_B8R8_2PLANE_444_UNORM => Some("G8_B8R8_2PLANE_444_UNORM"),
2172 Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 => {
2173 Some("G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16")
2174 }
2175 Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 => {
2176 Some("G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16")
2177 }
2178 Self::G16_B16R16_2PLANE_444_UNORM => Some("G16_B16R16_2PLANE_444_UNORM"),
2179 Self::A4R4G4B4_UNORM_PACK16 => Some("A4R4G4B4_UNORM_PACK16"),
2180 Self::A4B4G4R4_UNORM_PACK16 => Some("A4B4G4R4_UNORM_PACK16"),
2181 Self::ASTC_4X4_SFLOAT_BLOCK => Some("ASTC_4X4_SFLOAT_BLOCK"),
2182 Self::ASTC_5X4_SFLOAT_BLOCK => Some("ASTC_5X4_SFLOAT_BLOCK"),
2183 Self::ASTC_5X5_SFLOAT_BLOCK => Some("ASTC_5X5_SFLOAT_BLOCK"),
2184 Self::ASTC_6X5_SFLOAT_BLOCK => Some("ASTC_6X5_SFLOAT_BLOCK"),
2185 Self::ASTC_6X6_SFLOAT_BLOCK => Some("ASTC_6X6_SFLOAT_BLOCK"),
2186 Self::ASTC_8X5_SFLOAT_BLOCK => Some("ASTC_8X5_SFLOAT_BLOCK"),
2187 Self::ASTC_8X6_SFLOAT_BLOCK => Some("ASTC_8X6_SFLOAT_BLOCK"),
2188 Self::ASTC_8X8_SFLOAT_BLOCK => Some("ASTC_8X8_SFLOAT_BLOCK"),
2189 Self::ASTC_10X5_SFLOAT_BLOCK => Some("ASTC_10X5_SFLOAT_BLOCK"),
2190 Self::ASTC_10X6_SFLOAT_BLOCK => Some("ASTC_10X6_SFLOAT_BLOCK"),
2191 Self::ASTC_10X8_SFLOAT_BLOCK => Some("ASTC_10X8_SFLOAT_BLOCK"),
2192 Self::ASTC_10X10_SFLOAT_BLOCK => Some("ASTC_10X10_SFLOAT_BLOCK"),
2193 Self::ASTC_12X10_SFLOAT_BLOCK => Some("ASTC_12X10_SFLOAT_BLOCK"),
2194 Self::ASTC_12X12_SFLOAT_BLOCK => Some("ASTC_12X12_SFLOAT_BLOCK"),
2195 _ => None,
2196 };
2197 if let Some(x) = name {
2198 f.write_str(x)
2199 } else {
2200 self.0.fmt(f)
2201 }
2202 }
2203}
2204impl fmt::Debug for FormatFeatureFlags {
2205 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2206 const KNOWN : & [(Flags , & str)] = & [(FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_EXT . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_EXT") , (FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX")] ;
2207 debug_flags(f, KNOWN, self.0)
2208 }
2209}
2210impl fmt::Debug for FormatFeatureFlags2 {
2211 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2212 const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: RESERVED_44_EXT . 0 , "RESERVED_44_EXT") , (FormatFeatureFlags2 :: RESERVED_45_EXT . 0 , "RESERVED_45_EXT") , (FormatFeatureFlags2 :: RESERVED_46_EXT . 0 , "RESERVED_46_EXT") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: RESERVED_39_EXT . 0 , "RESERVED_39_EXT") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV")] ;
2213 debug_flags(f, KNOWN, self.0)
2214 }
2215}
2216impl fmt::Debug for FragmentShadingRateCombinerOpKHR {
2217 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2218 let name = match *self {
2219 Self::KEEP => Some("KEEP"),
2220 Self::REPLACE => Some("REPLACE"),
2221 Self::MIN => Some("MIN"),
2222 Self::MAX => Some("MAX"),
2223 Self::MUL => Some("MUL"),
2224 _ => None,
2225 };
2226 if let Some(x) = name {
2227 f.write_str(x)
2228 } else {
2229 self.0.fmt(f)
2230 }
2231 }
2232}
2233impl fmt::Debug for FragmentShadingRateNV {
2234 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2235 let name = match *self {
2236 Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"),
2237 Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"),
2238 Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"),
2239 Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"),
2240 Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"),
2241 Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"),
2242 Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"),
2243 Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"),
2244 Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"),
2245 Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"),
2246 Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"),
2247 Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"),
2248 _ => None,
2249 };
2250 if let Some(x) = name {
2251 f.write_str(x)
2252 } else {
2253 self.0.fmt(f)
2254 }
2255 }
2256}
2257impl fmt::Debug for FragmentShadingRateTypeNV {
2258 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2259 let name = match *self {
2260 Self::FRAGMENT_SIZE => Some("FRAGMENT_SIZE"),
2261 Self::ENUMS => Some("ENUMS"),
2262 _ => None,
2263 };
2264 if let Some(x) = name {
2265 f.write_str(x)
2266 } else {
2267 self.0.fmt(f)
2268 }
2269 }
2270}
2271impl fmt::Debug for FramebufferCreateFlags {
2272 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2273 const KNOWN: &[(Flags, &str)] = &[(FramebufferCreateFlags::IMAGELESS.0, "IMAGELESS")];
2274 debug_flags(f, KNOWN, self.0)
2275 }
2276}
2277impl fmt::Debug for FrontFace {
2278 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2279 let name = match *self {
2280 Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"),
2281 Self::CLOCKWISE => Some("CLOCKWISE"),
2282 _ => None,
2283 };
2284 if let Some(x) = name {
2285 f.write_str(x)
2286 } else {
2287 self.0.fmt(f)
2288 }
2289 }
2290}
2291impl fmt::Debug for FullScreenExclusiveEXT {
2292 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2293 let name = match *self {
2294 Self::DEFAULT => Some("DEFAULT"),
2295 Self::ALLOWED => Some("ALLOWED"),
2296 Self::DISALLOWED => Some("DISALLOWED"),
2297 Self::APPLICATION_CONTROLLED => Some("APPLICATION_CONTROLLED"),
2298 _ => None,
2299 };
2300 if let Some(x) = name {
2301 f.write_str(x)
2302 } else {
2303 self.0.fmt(f)
2304 }
2305 }
2306}
2307impl fmt::Debug for GeometryFlagsKHR {
2308 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2309 const KNOWN: &[(Flags, &str)] = &[
2310 (GeometryFlagsKHR::OPAQUE.0, "OPAQUE"),
2311 (
2312 GeometryFlagsKHR::NO_DUPLICATE_ANY_HIT_INVOCATION.0,
2313 "NO_DUPLICATE_ANY_HIT_INVOCATION",
2314 ),
2315 ];
2316 debug_flags(f, KNOWN, self.0)
2317 }
2318}
2319impl fmt::Debug for GeometryInstanceFlagsKHR {
2320 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2321 const KNOWN: &[(Flags, &str)] = &[
2322 (
2323 GeometryInstanceFlagsKHR::TRIANGLE_FACING_CULL_DISABLE.0,
2324 "TRIANGLE_FACING_CULL_DISABLE",
2325 ),
2326 (
2327 GeometryInstanceFlagsKHR::TRIANGLE_FLIP_FACING.0,
2328 "TRIANGLE_FLIP_FACING",
2329 ),
2330 (GeometryInstanceFlagsKHR::FORCE_OPAQUE.0, "FORCE_OPAQUE"),
2331 (
2332 GeometryInstanceFlagsKHR::FORCE_NO_OPAQUE.0,
2333 "FORCE_NO_OPAQUE",
2334 ),
2335 (
2336 GeometryInstanceFlagsKHR::FORCE_OPACITY_MICROMAP_2_STATE_EXT.0,
2337 "FORCE_OPACITY_MICROMAP_2_STATE_EXT",
2338 ),
2339 (
2340 GeometryInstanceFlagsKHR::DISABLE_OPACITY_MICROMAPS_EXT.0,
2341 "DISABLE_OPACITY_MICROMAPS_EXT",
2342 ),
2343 ];
2344 debug_flags(f, KNOWN, self.0)
2345 }
2346}
2347impl fmt::Debug for GeometryTypeKHR {
2348 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2349 let name = match *self {
2350 Self::TRIANGLES => Some("TRIANGLES"),
2351 Self::AABBS => Some("AABBS"),
2352 Self::INSTANCES => Some("INSTANCES"),
2353 _ => None,
2354 };
2355 if let Some(x) = name {
2356 f.write_str(x)
2357 } else {
2358 self.0.fmt(f)
2359 }
2360 }
2361}
2362impl fmt::Debug for GraphicsPipelineLibraryFlagsEXT {
2363 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2364 const KNOWN: &[(Flags, &str)] = &[
2365 (
2366 GraphicsPipelineLibraryFlagsEXT::VERTEX_INPUT_INTERFACE.0,
2367 "VERTEX_INPUT_INTERFACE",
2368 ),
2369 (
2370 GraphicsPipelineLibraryFlagsEXT::PRE_RASTERIZATION_SHADERS.0,
2371 "PRE_RASTERIZATION_SHADERS",
2372 ),
2373 (
2374 GraphicsPipelineLibraryFlagsEXT::FRAGMENT_SHADER.0,
2375 "FRAGMENT_SHADER",
2376 ),
2377 (
2378 GraphicsPipelineLibraryFlagsEXT::FRAGMENT_OUTPUT_INTERFACE.0,
2379 "FRAGMENT_OUTPUT_INTERFACE",
2380 ),
2381 ];
2382 debug_flags(f, KNOWN, self.0)
2383 }
2384}
2385impl fmt::Debug for HeadlessSurfaceCreateFlagsEXT {
2386 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2387 const KNOWN: &[(Flags, &str)] = &[];
2388 debug_flags(f, KNOWN, self.0)
2389 }
2390}
2391impl fmt::Debug for IOSSurfaceCreateFlagsMVK {
2392 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2393 const KNOWN: &[(Flags, &str)] = &[];
2394 debug_flags(f, KNOWN, self.0)
2395 }
2396}
2397impl fmt::Debug for ImageAspectFlags {
2398 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2399 const KNOWN: &[(Flags, &str)] = &[
2400 (ImageAspectFlags::COLOR.0, "COLOR"),
2401 (ImageAspectFlags::DEPTH.0, "DEPTH"),
2402 (ImageAspectFlags::STENCIL.0, "STENCIL"),
2403 (ImageAspectFlags::METADATA.0, "METADATA"),
2404 (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"),
2405 (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"),
2406 (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"),
2407 (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"),
2408 (ImageAspectFlags::PLANE_0.0, "PLANE_0"),
2409 (ImageAspectFlags::PLANE_1.0, "PLANE_1"),
2410 (ImageAspectFlags::PLANE_2.0, "PLANE_2"),
2411 (ImageAspectFlags::NONE.0, "NONE"),
2412 ];
2413 debug_flags(f, KNOWN, self.0)
2414 }
2415}
2416impl fmt::Debug for ImageCompressionFixedRateFlagsEXT {
2417 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2418 const KNOWN: &[(Flags, &str)] = &[
2419 (ImageCompressionFixedRateFlagsEXT::NONE.0, "NONE"),
2420 (ImageCompressionFixedRateFlagsEXT::TYPE_1BPC.0, "TYPE_1BPC"),
2421 (ImageCompressionFixedRateFlagsEXT::TYPE_2BPC.0, "TYPE_2BPC"),
2422 (ImageCompressionFixedRateFlagsEXT::TYPE_3BPC.0, "TYPE_3BPC"),
2423 (ImageCompressionFixedRateFlagsEXT::TYPE_4BPC.0, "TYPE_4BPC"),
2424 (ImageCompressionFixedRateFlagsEXT::TYPE_5BPC.0, "TYPE_5BPC"),
2425 (ImageCompressionFixedRateFlagsEXT::TYPE_6BPC.0, "TYPE_6BPC"),
2426 (ImageCompressionFixedRateFlagsEXT::TYPE_7BPC.0, "TYPE_7BPC"),
2427 (ImageCompressionFixedRateFlagsEXT::TYPE_8BPC.0, "TYPE_8BPC"),
2428 (ImageCompressionFixedRateFlagsEXT::TYPE_9BPC.0, "TYPE_9BPC"),
2429 (
2430 ImageCompressionFixedRateFlagsEXT::TYPE_10BPC.0,
2431 "TYPE_10BPC",
2432 ),
2433 (
2434 ImageCompressionFixedRateFlagsEXT::TYPE_11BPC.0,
2435 "TYPE_11BPC",
2436 ),
2437 (
2438 ImageCompressionFixedRateFlagsEXT::TYPE_12BPC.0,
2439 "TYPE_12BPC",
2440 ),
2441 (
2442 ImageCompressionFixedRateFlagsEXT::TYPE_13BPC.0,
2443 "TYPE_13BPC",
2444 ),
2445 (
2446 ImageCompressionFixedRateFlagsEXT::TYPE_14BPC.0,
2447 "TYPE_14BPC",
2448 ),
2449 (
2450 ImageCompressionFixedRateFlagsEXT::TYPE_15BPC.0,
2451 "TYPE_15BPC",
2452 ),
2453 (
2454 ImageCompressionFixedRateFlagsEXT::TYPE_16BPC.0,
2455 "TYPE_16BPC",
2456 ),
2457 (
2458 ImageCompressionFixedRateFlagsEXT::TYPE_17BPC.0,
2459 "TYPE_17BPC",
2460 ),
2461 (
2462 ImageCompressionFixedRateFlagsEXT::TYPE_18BPC.0,
2463 "TYPE_18BPC",
2464 ),
2465 (
2466 ImageCompressionFixedRateFlagsEXT::TYPE_19BPC.0,
2467 "TYPE_19BPC",
2468 ),
2469 (
2470 ImageCompressionFixedRateFlagsEXT::TYPE_20BPC.0,
2471 "TYPE_20BPC",
2472 ),
2473 (
2474 ImageCompressionFixedRateFlagsEXT::TYPE_21BPC.0,
2475 "TYPE_21BPC",
2476 ),
2477 (
2478 ImageCompressionFixedRateFlagsEXT::TYPE_22BPC.0,
2479 "TYPE_22BPC",
2480 ),
2481 (
2482 ImageCompressionFixedRateFlagsEXT::TYPE_23BPC.0,
2483 "TYPE_23BPC",
2484 ),
2485 (
2486 ImageCompressionFixedRateFlagsEXT::TYPE_24BPC.0,
2487 "TYPE_24BPC",
2488 ),
2489 ];
2490 debug_flags(f, KNOWN, self.0)
2491 }
2492}
2493impl fmt::Debug for ImageCompressionFlagsEXT {
2494 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2495 const KNOWN: &[(Flags, &str)] = &[
2496 (ImageCompressionFlagsEXT::DEFAULT.0, "DEFAULT"),
2497 (
2498 ImageCompressionFlagsEXT::FIXED_RATE_DEFAULT.0,
2499 "FIXED_RATE_DEFAULT",
2500 ),
2501 (
2502 ImageCompressionFlagsEXT::FIXED_RATE_EXPLICIT.0,
2503 "FIXED_RATE_EXPLICIT",
2504 ),
2505 (ImageCompressionFlagsEXT::DISABLED.0, "DISABLED"),
2506 ];
2507 debug_flags(f, KNOWN, self.0)
2508 }
2509}
2510impl fmt::Debug for ImageConstraintsInfoFlagsFUCHSIA {
2511 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2512 const KNOWN: &[(Flags, &str)] = &[
2513 (
2514 ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_RARELY.0,
2515 "CPU_READ_RARELY",
2516 ),
2517 (
2518 ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_OFTEN.0,
2519 "CPU_READ_OFTEN",
2520 ),
2521 (
2522 ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_RARELY.0,
2523 "CPU_WRITE_RARELY",
2524 ),
2525 (
2526 ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_OFTEN.0,
2527 "CPU_WRITE_OFTEN",
2528 ),
2529 (
2530 ImageConstraintsInfoFlagsFUCHSIA::PROTECTED_OPTIONAL.0,
2531 "PROTECTED_OPTIONAL",
2532 ),
2533 ];
2534 debug_flags(f, KNOWN, self.0)
2535 }
2536}
2537impl fmt::Debug for ImageCreateFlags {
2538 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2539 const KNOWN: &[(Flags, &str)] = &[
2540 (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"),
2541 (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"),
2542 (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"),
2543 (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"),
2544 (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"),
2545 (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"),
2546 (
2547 ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0,
2548 "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT",
2549 ),
2550 (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"),
2551 (ImageCreateFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"),
2552 (
2553 ImageCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
2554 "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
2555 ),
2556 (
2557 ImageCreateFlags::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT.0,
2558 "MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT",
2559 ),
2560 (
2561 ImageCreateFlags::TYPE_2D_VIEW_COMPATIBLE_EXT.0,
2562 "TYPE_2D_VIEW_COMPATIBLE_EXT",
2563 ),
2564 (
2565 ImageCreateFlags::FRAGMENT_DENSITY_MAP_OFFSET_QCOM.0,
2566 "FRAGMENT_DENSITY_MAP_OFFSET_QCOM",
2567 ),
2568 (ImageCreateFlags::RESERVED_20_KHR.0, "RESERVED_20_KHR"),
2569 (ImageCreateFlags::ALIAS.0, "ALIAS"),
2570 (
2571 ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0,
2572 "SPLIT_INSTANCE_BIND_REGIONS",
2573 ),
2574 (
2575 ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0,
2576 "TYPE_2D_ARRAY_COMPATIBLE",
2577 ),
2578 (
2579 ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0,
2580 "BLOCK_TEXEL_VIEW_COMPATIBLE",
2581 ),
2582 (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"),
2583 (ImageCreateFlags::PROTECTED.0, "PROTECTED"),
2584 (ImageCreateFlags::DISJOINT.0, "DISJOINT"),
2585 ];
2586 debug_flags(f, KNOWN, self.0)
2587 }
2588}
2589impl fmt::Debug for ImageFormatConstraintsFlagsFUCHSIA {
2590 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2591 const KNOWN: &[(Flags, &str)] = &[];
2592 debug_flags(f, KNOWN, self.0)
2593 }
2594}
2595impl fmt::Debug for ImageLayout {
2596 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2597 let name = match *self {
2598 Self::UNDEFINED => Some("UNDEFINED"),
2599 Self::GENERAL => Some("GENERAL"),
2600 Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"),
2601 Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"),
2602 Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"),
2603 Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"),
2604 Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"),
2605 Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"),
2606 Self::PREINITIALIZED => Some("PREINITIALIZED"),
2607 Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"),
2608 Self::VIDEO_DECODE_DST_KHR => Some("VIDEO_DECODE_DST_KHR"),
2609 Self::VIDEO_DECODE_SRC_KHR => Some("VIDEO_DECODE_SRC_KHR"),
2610 Self::VIDEO_DECODE_DPB_KHR => Some("VIDEO_DECODE_DPB_KHR"),
2611 Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"),
2612 Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"),
2613 Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR => {
2614 Some("FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR")
2615 }
2616 Self::VIDEO_ENCODE_DST_KHR => Some("VIDEO_ENCODE_DST_KHR"),
2617 Self::VIDEO_ENCODE_SRC_KHR => Some("VIDEO_ENCODE_SRC_KHR"),
2618 Self::VIDEO_ENCODE_DPB_KHR => Some("VIDEO_ENCODE_DPB_KHR"),
2619 Self::ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT => {
2620 Some("ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT")
2621 }
2622 Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => {
2623 Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL")
2624 }
2625 Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => {
2626 Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL")
2627 }
2628 Self::DEPTH_ATTACHMENT_OPTIMAL => Some("DEPTH_ATTACHMENT_OPTIMAL"),
2629 Self::DEPTH_READ_ONLY_OPTIMAL => Some("DEPTH_READ_ONLY_OPTIMAL"),
2630 Self::STENCIL_ATTACHMENT_OPTIMAL => Some("STENCIL_ATTACHMENT_OPTIMAL"),
2631 Self::STENCIL_READ_ONLY_OPTIMAL => Some("STENCIL_READ_ONLY_OPTIMAL"),
2632 Self::READ_ONLY_OPTIMAL => Some("READ_ONLY_OPTIMAL"),
2633 Self::ATTACHMENT_OPTIMAL => Some("ATTACHMENT_OPTIMAL"),
2634 _ => None,
2635 };
2636 if let Some(x) = name {
2637 f.write_str(x)
2638 } else {
2639 self.0.fmt(f)
2640 }
2641 }
2642}
2643impl fmt::Debug for ImagePipeSurfaceCreateFlagsFUCHSIA {
2644 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2645 const KNOWN: &[(Flags, &str)] = &[];
2646 debug_flags(f, KNOWN, self.0)
2647 }
2648}
2649impl fmt::Debug for ImageTiling {
2650 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2651 let name = match *self {
2652 Self::OPTIMAL => Some("OPTIMAL"),
2653 Self::LINEAR => Some("LINEAR"),
2654 Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"),
2655 _ => None,
2656 };
2657 if let Some(x) = name {
2658 f.write_str(x)
2659 } else {
2660 self.0.fmt(f)
2661 }
2662 }
2663}
2664impl fmt::Debug for ImageType {
2665 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2666 let name = match *self {
2667 Self::TYPE_1D => Some("TYPE_1D"),
2668 Self::TYPE_2D => Some("TYPE_2D"),
2669 Self::TYPE_3D => Some("TYPE_3D"),
2670 _ => None,
2671 };
2672 if let Some(x) = name {
2673 f.write_str(x)
2674 } else {
2675 self.0.fmt(f)
2676 }
2677 }
2678}
2679impl fmt::Debug for ImageUsageFlags {
2680 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2681 const KNOWN: &[(Flags, &str)] = &[
2682 (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"),
2683 (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"),
2684 (ImageUsageFlags::SAMPLED.0, "SAMPLED"),
2685 (ImageUsageFlags::STORAGE.0, "STORAGE"),
2686 (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"),
2687 (
2688 ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0,
2689 "DEPTH_STENCIL_ATTACHMENT",
2690 ),
2691 (
2692 ImageUsageFlags::TRANSIENT_ATTACHMENT.0,
2693 "TRANSIENT_ATTACHMENT",
2694 ),
2695 (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"),
2696 (
2697 ImageUsageFlags::VIDEO_DECODE_DST_KHR.0,
2698 "VIDEO_DECODE_DST_KHR",
2699 ),
2700 (
2701 ImageUsageFlags::VIDEO_DECODE_SRC_KHR.0,
2702 "VIDEO_DECODE_SRC_KHR",
2703 ),
2704 (
2705 ImageUsageFlags::VIDEO_DECODE_DPB_KHR.0,
2706 "VIDEO_DECODE_DPB_KHR",
2707 ),
2708 (ImageUsageFlags::RESERVED_16_QCOM.0, "RESERVED_16_QCOM"),
2709 (ImageUsageFlags::RESERVED_17_QCOM.0, "RESERVED_17_QCOM"),
2710 (
2711 ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0,
2712 "FRAGMENT_DENSITY_MAP_EXT",
2713 ),
2714 (
2715 ImageUsageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0,
2716 "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR",
2717 ),
2718 (ImageUsageFlags::RESERVED_22_EXT.0, "RESERVED_22_EXT"),
2719 (
2720 ImageUsageFlags::VIDEO_ENCODE_DST_KHR.0,
2721 "VIDEO_ENCODE_DST_KHR",
2722 ),
2723 (
2724 ImageUsageFlags::VIDEO_ENCODE_SRC_KHR.0,
2725 "VIDEO_ENCODE_SRC_KHR",
2726 ),
2727 (
2728 ImageUsageFlags::VIDEO_ENCODE_DPB_KHR.0,
2729 "VIDEO_ENCODE_DPB_KHR",
2730 ),
2731 (
2732 ImageUsageFlags::ATTACHMENT_FEEDBACK_LOOP_EXT.0,
2733 "ATTACHMENT_FEEDBACK_LOOP_EXT",
2734 ),
2735 (
2736 ImageUsageFlags::INVOCATION_MASK_HUAWEI.0,
2737 "INVOCATION_MASK_HUAWEI",
2738 ),
2739 (ImageUsageFlags::SAMPLE_WEIGHT_QCOM.0, "SAMPLE_WEIGHT_QCOM"),
2740 (
2741 ImageUsageFlags::SAMPLE_BLOCK_MATCH_QCOM.0,
2742 "SAMPLE_BLOCK_MATCH_QCOM",
2743 ),
2744 (ImageUsageFlags::RESERVED_23_EXT.0, "RESERVED_23_EXT"),
2745 ];
2746 debug_flags(f, KNOWN, self.0)
2747 }
2748}
2749impl fmt::Debug for ImageViewCreateFlags {
2750 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2751 const KNOWN: &[(Flags, &str)] = &[
2752 (
2753 ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0,
2754 "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT",
2755 ),
2756 (
2757 ImageViewCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
2758 "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
2759 ),
2760 (
2761 ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0,
2762 "FRAGMENT_DENSITY_MAP_DEFERRED_EXT",
2763 ),
2764 ];
2765 debug_flags(f, KNOWN, self.0)
2766 }
2767}
2768impl fmt::Debug for ImageViewType {
2769 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2770 let name = match *self {
2771 Self::TYPE_1D => Some("TYPE_1D"),
2772 Self::TYPE_2D => Some("TYPE_2D"),
2773 Self::TYPE_3D => Some("TYPE_3D"),
2774 Self::CUBE => Some("CUBE"),
2775 Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"),
2776 Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"),
2777 Self::CUBE_ARRAY => Some("CUBE_ARRAY"),
2778 _ => None,
2779 };
2780 if let Some(x) = name {
2781 f.write_str(x)
2782 } else {
2783 self.0.fmt(f)
2784 }
2785 }
2786}
2787impl fmt::Debug for IndexType {
2788 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2789 let name = match *self {
2790 Self::UINT16 => Some("UINT16"),
2791 Self::UINT32 => Some("UINT32"),
2792 Self::NONE_KHR => Some("NONE_KHR"),
2793 Self::UINT8_EXT => Some("UINT8_EXT"),
2794 _ => None,
2795 };
2796 if let Some(x) = name {
2797 f.write_str(x)
2798 } else {
2799 self.0.fmt(f)
2800 }
2801 }
2802}
2803impl fmt::Debug for IndirectCommandsLayoutUsageFlagsNV {
2804 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2805 const KNOWN: &[(Flags, &str)] = &[
2806 (
2807 IndirectCommandsLayoutUsageFlagsNV::EXPLICIT_PREPROCESS.0,
2808 "EXPLICIT_PREPROCESS",
2809 ),
2810 (
2811 IndirectCommandsLayoutUsageFlagsNV::INDEXED_SEQUENCES.0,
2812 "INDEXED_SEQUENCES",
2813 ),
2814 (
2815 IndirectCommandsLayoutUsageFlagsNV::UNORDERED_SEQUENCES.0,
2816 "UNORDERED_SEQUENCES",
2817 ),
2818 ];
2819 debug_flags(f, KNOWN, self.0)
2820 }
2821}
2822impl fmt::Debug for IndirectCommandsTokenTypeNV {
2823 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2824 let name = match *self {
2825 Self::SHADER_GROUP => Some("SHADER_GROUP"),
2826 Self::STATE_FLAGS => Some("STATE_FLAGS"),
2827 Self::INDEX_BUFFER => Some("INDEX_BUFFER"),
2828 Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"),
2829 Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"),
2830 Self::DRAW_INDEXED => Some("DRAW_INDEXED"),
2831 Self::DRAW => Some("DRAW"),
2832 Self::DRAW_TASKS => Some("DRAW_TASKS"),
2833 Self::DRAW_MESH_TASKS => Some("DRAW_MESH_TASKS"),
2834 _ => None,
2835 };
2836 if let Some(x) = name {
2837 f.write_str(x)
2838 } else {
2839 self.0.fmt(f)
2840 }
2841 }
2842}
2843impl fmt::Debug for IndirectStateFlagsNV {
2844 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2845 const KNOWN: &[(Flags, &str)] =
2846 &[(IndirectStateFlagsNV::FLAG_FRONTFACE.0, "FLAG_FRONTFACE")];
2847 debug_flags(f, KNOWN, self.0)
2848 }
2849}
2850impl fmt::Debug for InstanceCreateFlags {
2851 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2852 const KNOWN: &[(Flags, &str)] = &[(
2853 InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR.0,
2854 "ENUMERATE_PORTABILITY_KHR",
2855 )];
2856 debug_flags(f, KNOWN, self.0)
2857 }
2858}
2859impl fmt::Debug for InternalAllocationType {
2860 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2861 let name = match *self {
2862 Self::EXECUTABLE => Some("EXECUTABLE"),
2863 _ => None,
2864 };
2865 if let Some(x) = name {
2866 f.write_str(x)
2867 } else {
2868 self.0.fmt(f)
2869 }
2870 }
2871}
2872impl fmt::Debug for LineRasterizationModeEXT {
2873 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2874 let name = match *self {
2875 Self::DEFAULT => Some("DEFAULT"),
2876 Self::RECTANGULAR => Some("RECTANGULAR"),
2877 Self::BRESENHAM => Some("BRESENHAM"),
2878 Self::RECTANGULAR_SMOOTH => Some("RECTANGULAR_SMOOTH"),
2879 _ => None,
2880 };
2881 if let Some(x) = name {
2882 f.write_str(x)
2883 } else {
2884 self.0.fmt(f)
2885 }
2886 }
2887}
2888impl fmt::Debug for LogicOp {
2889 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2890 let name = match *self {
2891 Self::CLEAR => Some("CLEAR"),
2892 Self::AND => Some("AND"),
2893 Self::AND_REVERSE => Some("AND_REVERSE"),
2894 Self::COPY => Some("COPY"),
2895 Self::AND_INVERTED => Some("AND_INVERTED"),
2896 Self::NO_OP => Some("NO_OP"),
2897 Self::XOR => Some("XOR"),
2898 Self::OR => Some("OR"),
2899 Self::NOR => Some("NOR"),
2900 Self::EQUIVALENT => Some("EQUIVALENT"),
2901 Self::INVERT => Some("INVERT"),
2902 Self::OR_REVERSE => Some("OR_REVERSE"),
2903 Self::COPY_INVERTED => Some("COPY_INVERTED"),
2904 Self::OR_INVERTED => Some("OR_INVERTED"),
2905 Self::NAND => Some("NAND"),
2906 Self::SET => Some("SET"),
2907 _ => None,
2908 };
2909 if let Some(x) = name {
2910 f.write_str(x)
2911 } else {
2912 self.0.fmt(f)
2913 }
2914 }
2915}
2916impl fmt::Debug for MacOSSurfaceCreateFlagsMVK {
2917 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2918 const KNOWN: &[(Flags, &str)] = &[];
2919 debug_flags(f, KNOWN, self.0)
2920 }
2921}
2922impl fmt::Debug for MemoryAllocateFlags {
2923 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2924 const KNOWN: &[(Flags, &str)] = &[
2925 (MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK"),
2926 (MemoryAllocateFlags::DEVICE_ADDRESS.0, "DEVICE_ADDRESS"),
2927 (
2928 MemoryAllocateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
2929 "DEVICE_ADDRESS_CAPTURE_REPLAY",
2930 ),
2931 ];
2932 debug_flags(f, KNOWN, self.0)
2933 }
2934}
2935impl fmt::Debug for MemoryDecompressionMethodFlagsNV {
2936 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2937 const KNOWN: &[(Flags64, &str)] = &[(
2938 MemoryDecompressionMethodFlagsNV::GDEFLATE_1_0.0,
2939 "GDEFLATE_1_0",
2940 )];
2941 debug_flags(f, KNOWN, self.0)
2942 }
2943}
2944impl fmt::Debug for MemoryHeapFlags {
2945 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2946 const KNOWN: &[(Flags, &str)] = &[
2947 (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"),
2948 (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"),
2949 ];
2950 debug_flags(f, KNOWN, self.0)
2951 }
2952}
2953impl fmt::Debug for MemoryMapFlags {
2954 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2955 const KNOWN: &[(Flags, &str)] = &[];
2956 debug_flags(f, KNOWN, self.0)
2957 }
2958}
2959impl fmt::Debug for MemoryOverallocationBehaviorAMD {
2960 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2961 let name = match *self {
2962 Self::DEFAULT => Some("DEFAULT"),
2963 Self::ALLOWED => Some("ALLOWED"),
2964 Self::DISALLOWED => Some("DISALLOWED"),
2965 _ => None,
2966 };
2967 if let Some(x) = name {
2968 f.write_str(x)
2969 } else {
2970 self.0.fmt(f)
2971 }
2972 }
2973}
2974impl fmt::Debug for MemoryPropertyFlags {
2975 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2976 const KNOWN: &[(Flags, &str)] = &[
2977 (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"),
2978 (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"),
2979 (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"),
2980 (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"),
2981 (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"),
2982 (
2983 MemoryPropertyFlags::DEVICE_COHERENT_AMD.0,
2984 "DEVICE_COHERENT_AMD",
2985 ),
2986 (
2987 MemoryPropertyFlags::DEVICE_UNCACHED_AMD.0,
2988 "DEVICE_UNCACHED_AMD",
2989 ),
2990 (MemoryPropertyFlags::RDMA_CAPABLE_NV.0, "RDMA_CAPABLE_NV"),
2991 (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"),
2992 ];
2993 debug_flags(f, KNOWN, self.0)
2994 }
2995}
2996impl fmt::Debug for MemoryUnmapFlagsKHR {
2997 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2998 const KNOWN: &[(Flags, &str)] = &[];
2999 debug_flags(f, KNOWN, self.0)
3000 }
3001}
3002impl fmt::Debug for MetalSurfaceCreateFlagsEXT {
3003 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3004 const KNOWN: &[(Flags, &str)] = &[];
3005 debug_flags(f, KNOWN, self.0)
3006 }
3007}
3008impl fmt::Debug for MicromapCreateFlagsEXT {
3009 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3010 const KNOWN: &[(Flags, &str)] = &[(
3011 MicromapCreateFlagsEXT::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
3012 "DEVICE_ADDRESS_CAPTURE_REPLAY",
3013 )];
3014 debug_flags(f, KNOWN, self.0)
3015 }
3016}
3017impl fmt::Debug for MicromapTypeEXT {
3018 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3019 let name = match *self {
3020 Self::OPACITY_MICROMAP => Some("OPACITY_MICROMAP"),
3021 Self::DISPLACEMENT_MICROMAP_NV => Some("DISPLACEMENT_MICROMAP_NV"),
3022 _ => None,
3023 };
3024 if let Some(x) = name {
3025 f.write_str(x)
3026 } else {
3027 self.0.fmt(f)
3028 }
3029 }
3030}
3031impl fmt::Debug for OpacityMicromapFormatEXT {
3032 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3033 let name = match *self {
3034 Self::TYPE_2_STATE => Some("TYPE_2_STATE"),
3035 Self::TYPE_4_STATE => Some("TYPE_4_STATE"),
3036 _ => None,
3037 };
3038 if let Some(x) = name {
3039 f.write_str(x)
3040 } else {
3041 self.0.fmt(f)
3042 }
3043 }
3044}
3045impl fmt::Debug for OpacityMicromapSpecialIndexEXT {
3046 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3047 let name = match *self {
3048 Self::FULLY_TRANSPARENT => Some("FULLY_TRANSPARENT"),
3049 Self::FULLY_OPAQUE => Some("FULLY_OPAQUE"),
3050 Self::FULLY_UNKNOWN_TRANSPARENT => Some("FULLY_UNKNOWN_TRANSPARENT"),
3051 Self::FULLY_UNKNOWN_OPAQUE => Some("FULLY_UNKNOWN_OPAQUE"),
3052 _ => None,
3053 };
3054 if let Some(x) = name {
3055 f.write_str(x)
3056 } else {
3057 self.0.fmt(f)
3058 }
3059 }
3060}
3061impl fmt::Debug for OpticalFlowExecuteFlagsNV {
3062 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3063 const KNOWN: &[(Flags, &str)] = &[(
3064 OpticalFlowExecuteFlagsNV::DISABLE_TEMPORAL_HINTS.0,
3065 "DISABLE_TEMPORAL_HINTS",
3066 )];
3067 debug_flags(f, KNOWN, self.0)
3068 }
3069}
3070impl fmt::Debug for OpticalFlowGridSizeFlagsNV {
3071 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3072 const KNOWN: &[(Flags, &str)] = &[
3073 (OpticalFlowGridSizeFlagsNV::UNKNOWN.0, "UNKNOWN"),
3074 (OpticalFlowGridSizeFlagsNV::TYPE_1X1.0, "TYPE_1X1"),
3075 (OpticalFlowGridSizeFlagsNV::TYPE_2X2.0, "TYPE_2X2"),
3076 (OpticalFlowGridSizeFlagsNV::TYPE_4X4.0, "TYPE_4X4"),
3077 (OpticalFlowGridSizeFlagsNV::TYPE_8X8.0, "TYPE_8X8"),
3078 ];
3079 debug_flags(f, KNOWN, self.0)
3080 }
3081}
3082impl fmt::Debug for OpticalFlowPerformanceLevelNV {
3083 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3084 let name = match *self {
3085 Self::UNKNOWN => Some("UNKNOWN"),
3086 Self::SLOW => Some("SLOW"),
3087 Self::MEDIUM => Some("MEDIUM"),
3088 Self::FAST => Some("FAST"),
3089 _ => None,
3090 };
3091 if let Some(x) = name {
3092 f.write_str(x)
3093 } else {
3094 self.0.fmt(f)
3095 }
3096 }
3097}
3098impl fmt::Debug for OpticalFlowSessionBindingPointNV {
3099 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3100 let name = match *self {
3101 Self::UNKNOWN => Some("UNKNOWN"),
3102 Self::INPUT => Some("INPUT"),
3103 Self::REFERENCE => Some("REFERENCE"),
3104 Self::HINT => Some("HINT"),
3105 Self::FLOW_VECTOR => Some("FLOW_VECTOR"),
3106 Self::BACKWARD_FLOW_VECTOR => Some("BACKWARD_FLOW_VECTOR"),
3107 Self::COST => Some("COST"),
3108 Self::BACKWARD_COST => Some("BACKWARD_COST"),
3109 Self::GLOBAL_FLOW => Some("GLOBAL_FLOW"),
3110 _ => None,
3111 };
3112 if let Some(x) = name {
3113 f.write_str(x)
3114 } else {
3115 self.0.fmt(f)
3116 }
3117 }
3118}
3119impl fmt::Debug for OpticalFlowSessionCreateFlagsNV {
3120 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3121 const KNOWN: &[(Flags, &str)] = &[
3122 (
3123 OpticalFlowSessionCreateFlagsNV::ENABLE_HINT.0,
3124 "ENABLE_HINT",
3125 ),
3126 (
3127 OpticalFlowSessionCreateFlagsNV::ENABLE_COST.0,
3128 "ENABLE_COST",
3129 ),
3130 (
3131 OpticalFlowSessionCreateFlagsNV::ENABLE_GLOBAL_FLOW.0,
3132 "ENABLE_GLOBAL_FLOW",
3133 ),
3134 (
3135 OpticalFlowSessionCreateFlagsNV::ALLOW_REGIONS.0,
3136 "ALLOW_REGIONS",
3137 ),
3138 (
3139 OpticalFlowSessionCreateFlagsNV::BOTH_DIRECTIONS.0,
3140 "BOTH_DIRECTIONS",
3141 ),
3142 ];
3143 debug_flags(f, KNOWN, self.0)
3144 }
3145}
3146impl fmt::Debug for OpticalFlowUsageFlagsNV {
3147 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3148 const KNOWN: &[(Flags, &str)] = &[
3149 (OpticalFlowUsageFlagsNV::UNKNOWN.0, "UNKNOWN"),
3150 (OpticalFlowUsageFlagsNV::INPUT.0, "INPUT"),
3151 (OpticalFlowUsageFlagsNV::OUTPUT.0, "OUTPUT"),
3152 (OpticalFlowUsageFlagsNV::HINT.0, "HINT"),
3153 (OpticalFlowUsageFlagsNV::COST.0, "COST"),
3154 (OpticalFlowUsageFlagsNV::GLOBAL_FLOW.0, "GLOBAL_FLOW"),
3155 ];
3156 debug_flags(f, KNOWN, self.0)
3157 }
3158}
3159impl fmt::Debug for PeerMemoryFeatureFlags {
3160 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3161 const KNOWN: &[(Flags, &str)] = &[
3162 (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"),
3163 (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"),
3164 (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"),
3165 (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"),
3166 ];
3167 debug_flags(f, KNOWN, self.0)
3168 }
3169}
3170impl fmt::Debug for PerformanceConfigurationTypeINTEL {
3171 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3172 let name = match *self {
3173 Self::COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED => {
3174 Some("COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED")
3175 }
3176 _ => None,
3177 };
3178 if let Some(x) = name {
3179 f.write_str(x)
3180 } else {
3181 self.0.fmt(f)
3182 }
3183 }
3184}
3185impl fmt::Debug for PerformanceCounterDescriptionFlagsKHR {
3186 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3187 const KNOWN: &[(Flags, &str)] = &[
3188 (
3189 PerformanceCounterDescriptionFlagsKHR::PERFORMANCE_IMPACTING.0,
3190 "PERFORMANCE_IMPACTING",
3191 ),
3192 (
3193 PerformanceCounterDescriptionFlagsKHR::CONCURRENTLY_IMPACTED.0,
3194 "CONCURRENTLY_IMPACTED",
3195 ),
3196 ];
3197 debug_flags(f, KNOWN, self.0)
3198 }
3199}
3200impl fmt::Debug for PerformanceCounterScopeKHR {
3201 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3202 let name = match *self {
3203 Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"),
3204 Self::RENDER_PASS => Some("RENDER_PASS"),
3205 Self::COMMAND => Some("COMMAND"),
3206 _ => None,
3207 };
3208 if let Some(x) = name {
3209 f.write_str(x)
3210 } else {
3211 self.0.fmt(f)
3212 }
3213 }
3214}
3215impl fmt::Debug for PerformanceCounterStorageKHR {
3216 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3217 let name = match *self {
3218 Self::INT32 => Some("INT32"),
3219 Self::INT64 => Some("INT64"),
3220 Self::UINT32 => Some("UINT32"),
3221 Self::UINT64 => Some("UINT64"),
3222 Self::FLOAT32 => Some("FLOAT32"),
3223 Self::FLOAT64 => Some("FLOAT64"),
3224 _ => None,
3225 };
3226 if let Some(x) = name {
3227 f.write_str(x)
3228 } else {
3229 self.0.fmt(f)
3230 }
3231 }
3232}
3233impl fmt::Debug for PerformanceCounterUnitKHR {
3234 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3235 let name = match *self {
3236 Self::GENERIC => Some("GENERIC"),
3237 Self::PERCENTAGE => Some("PERCENTAGE"),
3238 Self::NANOSECONDS => Some("NANOSECONDS"),
3239 Self::BYTES => Some("BYTES"),
3240 Self::BYTES_PER_SECOND => Some("BYTES_PER_SECOND"),
3241 Self::KELVIN => Some("KELVIN"),
3242 Self::WATTS => Some("WATTS"),
3243 Self::VOLTS => Some("VOLTS"),
3244 Self::AMPS => Some("AMPS"),
3245 Self::HERTZ => Some("HERTZ"),
3246 Self::CYCLES => Some("CYCLES"),
3247 _ => None,
3248 };
3249 if let Some(x) = name {
3250 f.write_str(x)
3251 } else {
3252 self.0.fmt(f)
3253 }
3254 }
3255}
3256impl fmt::Debug for PerformanceOverrideTypeINTEL {
3257 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3258 let name = match *self {
3259 Self::NULL_HARDWARE => Some("NULL_HARDWARE"),
3260 Self::FLUSH_GPU_CACHES => Some("FLUSH_GPU_CACHES"),
3261 _ => None,
3262 };
3263 if let Some(x) = name {
3264 f.write_str(x)
3265 } else {
3266 self.0.fmt(f)
3267 }
3268 }
3269}
3270impl fmt::Debug for PerformanceParameterTypeINTEL {
3271 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3272 let name = match *self {
3273 Self::HW_COUNTERS_SUPPORTED => Some("HW_COUNTERS_SUPPORTED"),
3274 Self::STREAM_MARKER_VALIDS => Some("STREAM_MARKER_VALIDS"),
3275 _ => None,
3276 };
3277 if let Some(x) = name {
3278 f.write_str(x)
3279 } else {
3280 self.0.fmt(f)
3281 }
3282 }
3283}
3284impl fmt::Debug for PerformanceValueTypeINTEL {
3285 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3286 let name = match *self {
3287 Self::UINT32 => Some("UINT32"),
3288 Self::UINT64 => Some("UINT64"),
3289 Self::FLOAT => Some("FLOAT"),
3290 Self::BOOL => Some("BOOL"),
3291 Self::STRING => Some("STRING"),
3292 _ => None,
3293 };
3294 if let Some(x) = name {
3295 f.write_str(x)
3296 } else {
3297 self.0.fmt(f)
3298 }
3299 }
3300}
3301impl fmt::Debug for PhysicalDeviceType {
3302 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3303 let name = match *self {
3304 Self::OTHER => Some("OTHER"),
3305 Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"),
3306 Self::DISCRETE_GPU => Some("DISCRETE_GPU"),
3307 Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"),
3308 Self::CPU => Some("CPU"),
3309 _ => None,
3310 };
3311 if let Some(x) = name {
3312 f.write_str(x)
3313 } else {
3314 self.0.fmt(f)
3315 }
3316 }
3317}
3318impl fmt::Debug for PipelineBindPoint {
3319 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3320 let name = match *self {
3321 Self::GRAPHICS => Some("GRAPHICS"),
3322 Self::COMPUTE => Some("COMPUTE"),
3323 Self::RAY_TRACING_KHR => Some("RAY_TRACING_KHR"),
3324 Self::SUBPASS_SHADING_HUAWEI => Some("SUBPASS_SHADING_HUAWEI"),
3325 _ => None,
3326 };
3327 if let Some(x) = name {
3328 f.write_str(x)
3329 } else {
3330 self.0.fmt(f)
3331 }
3332 }
3333}
3334impl fmt::Debug for PipelineCacheCreateFlags {
3335 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3336 const KNOWN: &[(Flags, &str)] = &[(
3337 PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED.0,
3338 "EXTERNALLY_SYNCHRONIZED",
3339 )];
3340 debug_flags(f, KNOWN, self.0)
3341 }
3342}
3343impl fmt::Debug for PipelineCacheHeaderVersion {
3344 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3345 let name = match *self {
3346 Self::ONE => Some("ONE"),
3347 _ => None,
3348 };
3349 if let Some(x) = name {
3350 f.write_str(x)
3351 } else {
3352 self.0.fmt(f)
3353 }
3354 }
3355}
3356impl fmt::Debug for PipelineColorBlendStateCreateFlags {
3357 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3358 const KNOWN: &[(Flags, &str)] = &[(
3359 PipelineColorBlendStateCreateFlags::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT.0,
3360 "RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT",
3361 )];
3362 debug_flags(f, KNOWN, self.0)
3363 }
3364}
3365impl fmt::Debug for PipelineCompilerControlFlagsAMD {
3366 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3367 const KNOWN: &[(Flags, &str)] = &[];
3368 debug_flags(f, KNOWN, self.0)
3369 }
3370}
3371impl fmt::Debug for PipelineCoverageModulationStateCreateFlagsNV {
3372 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3373 const KNOWN: &[(Flags, &str)] = &[];
3374 debug_flags(f, KNOWN, self.0)
3375 }
3376}
3377impl fmt::Debug for PipelineCoverageReductionStateCreateFlagsNV {
3378 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3379 const KNOWN: &[(Flags, &str)] = &[];
3380 debug_flags(f, KNOWN, self.0)
3381 }
3382}
3383impl fmt::Debug for PipelineCoverageToColorStateCreateFlagsNV {
3384 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3385 const KNOWN: &[(Flags, &str)] = &[];
3386 debug_flags(f, KNOWN, self.0)
3387 }
3388}
3389impl fmt::Debug for PipelineCreateFlags {
3390 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3391 const KNOWN: &[(Flags, &str)] = &[
3392 (
3393 PipelineCreateFlags::DISABLE_OPTIMIZATION.0,
3394 "DISABLE_OPTIMIZATION",
3395 ),
3396 (
3397 PipelineCreateFlags::ALLOW_DERIVATIVES.0,
3398 "ALLOW_DERIVATIVES",
3399 ),
3400 (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"),
3401 (
3402 PipelineCreateFlags::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0,
3403 "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR",
3404 ),
3405 (
3406 PipelineCreateFlags::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0,
3407 "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT",
3408 ),
3409 (
3410 PipelineCreateFlags::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0,
3411 "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR",
3412 ),
3413 (
3414 PipelineCreateFlags::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR.0,
3415 "RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR",
3416 ),
3417 (
3418 PipelineCreateFlags::RAY_TRACING_NO_NULL_MISS_SHADERS_KHR.0,
3419 "RAY_TRACING_NO_NULL_MISS_SHADERS_KHR",
3420 ),
3421 (
3422 PipelineCreateFlags::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR.0,
3423 "RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR",
3424 ),
3425 (
3426 PipelineCreateFlags::RAY_TRACING_SKIP_TRIANGLES_KHR.0,
3427 "RAY_TRACING_SKIP_TRIANGLES_KHR",
3428 ),
3429 (
3430 PipelineCreateFlags::RAY_TRACING_SKIP_AABBS_KHR.0,
3431 "RAY_TRACING_SKIP_AABBS_KHR",
3432 ),
3433 (
3434 PipelineCreateFlags::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR.0,
3435 "RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR",
3436 ),
3437 (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"),
3438 (
3439 PipelineCreateFlags::CAPTURE_STATISTICS_KHR.0,
3440 "CAPTURE_STATISTICS_KHR",
3441 ),
3442 (
3443 PipelineCreateFlags::CAPTURE_INTERNAL_REPRESENTATIONS_KHR.0,
3444 "CAPTURE_INTERNAL_REPRESENTATIONS_KHR",
3445 ),
3446 (
3447 PipelineCreateFlags::INDIRECT_BINDABLE_NV.0,
3448 "INDIRECT_BINDABLE_NV",
3449 ),
3450 (PipelineCreateFlags::LIBRARY_KHR.0, "LIBRARY_KHR"),
3451 (
3452 PipelineCreateFlags::DESCRIPTOR_BUFFER_EXT.0,
3453 "DESCRIPTOR_BUFFER_EXT",
3454 ),
3455 (
3456 PipelineCreateFlags::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT.0,
3457 "RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT",
3458 ),
3459 (
3460 PipelineCreateFlags::LINK_TIME_OPTIMIZATION_EXT.0,
3461 "LINK_TIME_OPTIMIZATION_EXT",
3462 ),
3463 (
3464 PipelineCreateFlags::RAY_TRACING_ALLOW_MOTION_NV.0,
3465 "RAY_TRACING_ALLOW_MOTION_NV",
3466 ),
3467 (
3468 PipelineCreateFlags::COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT.0,
3469 "COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT",
3470 ),
3471 (
3472 PipelineCreateFlags::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT.0,
3473 "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT",
3474 ),
3475 (
3476 PipelineCreateFlags::RAY_TRACING_OPACITY_MICROMAP_EXT.0,
3477 "RAY_TRACING_OPACITY_MICROMAP_EXT",
3478 ),
3479 (
3480 PipelineCreateFlags::RAY_TRACING_DISPLACEMENT_MICROMAP_NV.0,
3481 "RAY_TRACING_DISPLACEMENT_MICROMAP_NV",
3482 ),
3483 (
3484 PipelineCreateFlags::NO_PROTECTED_ACCESS_EXT.0,
3485 "NO_PROTECTED_ACCESS_EXT",
3486 ),
3487 (
3488 PipelineCreateFlags::PROTECTED_ACCESS_ONLY_EXT.0,
3489 "PROTECTED_ACCESS_ONLY_EXT",
3490 ),
3491 (
3492 PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0,
3493 "VIEW_INDEX_FROM_DEVICE_INDEX",
3494 ),
3495 (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"),
3496 (
3497 PipelineCreateFlags::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0,
3498 "FAIL_ON_PIPELINE_COMPILE_REQUIRED",
3499 ),
3500 (
3501 PipelineCreateFlags::EARLY_RETURN_ON_FAILURE.0,
3502 "EARLY_RETURN_ON_FAILURE",
3503 ),
3504 ];
3505 debug_flags(f, KNOWN, self.0)
3506 }
3507}
3508impl fmt::Debug for PipelineCreationFeedbackFlags {
3509 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3510 const KNOWN: &[(Flags, &str)] = &[
3511 (PipelineCreationFeedbackFlags::VALID.0, "VALID"),
3512 (
3513 PipelineCreationFeedbackFlags::APPLICATION_PIPELINE_CACHE_HIT.0,
3514 "APPLICATION_PIPELINE_CACHE_HIT",
3515 ),
3516 (
3517 PipelineCreationFeedbackFlags::BASE_PIPELINE_ACCELERATION.0,
3518 "BASE_PIPELINE_ACCELERATION",
3519 ),
3520 ];
3521 debug_flags(f, KNOWN, self.0)
3522 }
3523}
3524impl fmt::Debug for PipelineDepthStencilStateCreateFlags {
3525 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3526 const KNOWN : & [(Flags , & str)] = & [(PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT . 0 , "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT") , (PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT . 0 , "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT")] ;
3527 debug_flags(f, KNOWN, self.0)
3528 }
3529}
3530impl fmt::Debug for PipelineDiscardRectangleStateCreateFlagsEXT {
3531 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3532 const KNOWN: &[(Flags, &str)] = &[];
3533 debug_flags(f, KNOWN, self.0)
3534 }
3535}
3536impl fmt::Debug for PipelineDynamicStateCreateFlags {
3537 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3538 const KNOWN: &[(Flags, &str)] = &[];
3539 debug_flags(f, KNOWN, self.0)
3540 }
3541}
3542impl fmt::Debug for PipelineExecutableStatisticFormatKHR {
3543 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3544 let name = match *self {
3545 Self::BOOL32 => Some("BOOL32"),
3546 Self::INT64 => Some("INT64"),
3547 Self::UINT64 => Some("UINT64"),
3548 Self::FLOAT64 => Some("FLOAT64"),
3549 _ => None,
3550 };
3551 if let Some(x) = name {
3552 f.write_str(x)
3553 } else {
3554 self.0.fmt(f)
3555 }
3556 }
3557}
3558impl fmt::Debug for PipelineInputAssemblyStateCreateFlags {
3559 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3560 const KNOWN: &[(Flags, &str)] = &[];
3561 debug_flags(f, KNOWN, self.0)
3562 }
3563}
3564impl fmt::Debug for PipelineLayoutCreateFlags {
3565 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3566 const KNOWN: &[(Flags, &str)] = &[
3567 (
3568 PipelineLayoutCreateFlags::RESERVED_0_AMD.0,
3569 "RESERVED_0_AMD",
3570 ),
3571 (
3572 PipelineLayoutCreateFlags::INDEPENDENT_SETS_EXT.0,
3573 "INDEPENDENT_SETS_EXT",
3574 ),
3575 ];
3576 debug_flags(f, KNOWN, self.0)
3577 }
3578}
3579impl fmt::Debug for PipelineMultisampleStateCreateFlags {
3580 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3581 const KNOWN: &[(Flags, &str)] = &[];
3582 debug_flags(f, KNOWN, self.0)
3583 }
3584}
3585impl fmt::Debug for PipelineRasterizationConservativeStateCreateFlagsEXT {
3586 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3587 const KNOWN: &[(Flags, &str)] = &[];
3588 debug_flags(f, KNOWN, self.0)
3589 }
3590}
3591impl fmt::Debug for PipelineRasterizationDepthClipStateCreateFlagsEXT {
3592 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3593 const KNOWN: &[(Flags, &str)] = &[];
3594 debug_flags(f, KNOWN, self.0)
3595 }
3596}
3597impl fmt::Debug for PipelineRasterizationStateCreateFlags {
3598 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3599 const KNOWN: &[(Flags, &str)] = &[];
3600 debug_flags(f, KNOWN, self.0)
3601 }
3602}
3603impl fmt::Debug for PipelineRasterizationStateStreamCreateFlagsEXT {
3604 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3605 const KNOWN: &[(Flags, &str)] = &[];
3606 debug_flags(f, KNOWN, self.0)
3607 }
3608}
3609impl fmt::Debug for PipelineRobustnessBufferBehaviorEXT {
3610 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3611 let name = match *self {
3612 Self::DEVICE_DEFAULT => Some("DEVICE_DEFAULT"),
3613 Self::DISABLED => Some("DISABLED"),
3614 Self::ROBUST_BUFFER_ACCESS => Some("ROBUST_BUFFER_ACCESS"),
3615 Self::ROBUST_BUFFER_ACCESS_2 => Some("ROBUST_BUFFER_ACCESS_2"),
3616 _ => None,
3617 };
3618 if let Some(x) = name {
3619 f.write_str(x)
3620 } else {
3621 self.0.fmt(f)
3622 }
3623 }
3624}
3625impl fmt::Debug for PipelineRobustnessImageBehaviorEXT {
3626 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3627 let name = match *self {
3628 Self::DEVICE_DEFAULT => Some("DEVICE_DEFAULT"),
3629 Self::DISABLED => Some("DISABLED"),
3630 Self::ROBUST_IMAGE_ACCESS => Some("ROBUST_IMAGE_ACCESS"),
3631 Self::ROBUST_IMAGE_ACCESS_2 => Some("ROBUST_IMAGE_ACCESS_2"),
3632 _ => None,
3633 };
3634 if let Some(x) = name {
3635 f.write_str(x)
3636 } else {
3637 self.0.fmt(f)
3638 }
3639 }
3640}
3641impl fmt::Debug for PipelineShaderStageCreateFlags {
3642 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3643 const KNOWN: &[(Flags, &str)] = &[
3644 (
3645 PipelineShaderStageCreateFlags::RESERVED_3_KHR.0,
3646 "RESERVED_3_KHR",
3647 ),
3648 (
3649 PipelineShaderStageCreateFlags::ALLOW_VARYING_SUBGROUP_SIZE.0,
3650 "ALLOW_VARYING_SUBGROUP_SIZE",
3651 ),
3652 (
3653 PipelineShaderStageCreateFlags::REQUIRE_FULL_SUBGROUPS.0,
3654 "REQUIRE_FULL_SUBGROUPS",
3655 ),
3656 ];
3657 debug_flags(f, KNOWN, self.0)
3658 }
3659}
3660impl fmt::Debug for PipelineStageFlags {
3661 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3662 const KNOWN: &[(Flags, &str)] = &[
3663 (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"),
3664 (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"),
3665 (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"),
3666 (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"),
3667 (
3668 PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0,
3669 "TESSELLATION_CONTROL_SHADER",
3670 ),
3671 (
3672 PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0,
3673 "TESSELLATION_EVALUATION_SHADER",
3674 ),
3675 (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"),
3676 (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"),
3677 (
3678 PipelineStageFlags::EARLY_FRAGMENT_TESTS.0,
3679 "EARLY_FRAGMENT_TESTS",
3680 ),
3681 (
3682 PipelineStageFlags::LATE_FRAGMENT_TESTS.0,
3683 "LATE_FRAGMENT_TESTS",
3684 ),
3685 (
3686 PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0,
3687 "COLOR_ATTACHMENT_OUTPUT",
3688 ),
3689 (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"),
3690 (PipelineStageFlags::TRANSFER.0, "TRANSFER"),
3691 (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"),
3692 (PipelineStageFlags::HOST.0, "HOST"),
3693 (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"),
3694 (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"),
3695 (
3696 PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0,
3697 "TRANSFORM_FEEDBACK_EXT",
3698 ),
3699 (
3700 PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0,
3701 "CONDITIONAL_RENDERING_EXT",
3702 ),
3703 (
3704 PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR.0,
3705 "ACCELERATION_STRUCTURE_BUILD_KHR",
3706 ),
3707 (
3708 PipelineStageFlags::RAY_TRACING_SHADER_KHR.0,
3709 "RAY_TRACING_SHADER_KHR",
3710 ),
3711 (
3712 PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0,
3713 "FRAGMENT_DENSITY_PROCESS_EXT",
3714 ),
3715 (
3716 PipelineStageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0,
3717 "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR",
3718 ),
3719 (
3720 PipelineStageFlags::COMMAND_PREPROCESS_NV.0,
3721 "COMMAND_PREPROCESS_NV",
3722 ),
3723 (PipelineStageFlags::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"),
3724 (PipelineStageFlags::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"),
3725 (PipelineStageFlags::NONE.0, "NONE"),
3726 ];
3727 debug_flags(f, KNOWN, self.0)
3728 }
3729}
3730impl fmt::Debug for PipelineStageFlags2 {
3731 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3732 const KNOWN: &[(Flags64, &str)] = &[
3733 (PipelineStageFlags2::NONE.0, "NONE"),
3734 (PipelineStageFlags2::TOP_OF_PIPE.0, "TOP_OF_PIPE"),
3735 (PipelineStageFlags2::DRAW_INDIRECT.0, "DRAW_INDIRECT"),
3736 (PipelineStageFlags2::VERTEX_INPUT.0, "VERTEX_INPUT"),
3737 (PipelineStageFlags2::VERTEX_SHADER.0, "VERTEX_SHADER"),
3738 (
3739 PipelineStageFlags2::TESSELLATION_CONTROL_SHADER.0,
3740 "TESSELLATION_CONTROL_SHADER",
3741 ),
3742 (
3743 PipelineStageFlags2::TESSELLATION_EVALUATION_SHADER.0,
3744 "TESSELLATION_EVALUATION_SHADER",
3745 ),
3746 (PipelineStageFlags2::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"),
3747 (PipelineStageFlags2::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"),
3748 (
3749 PipelineStageFlags2::EARLY_FRAGMENT_TESTS.0,
3750 "EARLY_FRAGMENT_TESTS",
3751 ),
3752 (
3753 PipelineStageFlags2::LATE_FRAGMENT_TESTS.0,
3754 "LATE_FRAGMENT_TESTS",
3755 ),
3756 (
3757 PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT.0,
3758 "COLOR_ATTACHMENT_OUTPUT",
3759 ),
3760 (PipelineStageFlags2::COMPUTE_SHADER.0, "COMPUTE_SHADER"),
3761 (PipelineStageFlags2::ALL_TRANSFER.0, "ALL_TRANSFER"),
3762 (PipelineStageFlags2::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"),
3763 (PipelineStageFlags2::HOST.0, "HOST"),
3764 (PipelineStageFlags2::ALL_GRAPHICS.0, "ALL_GRAPHICS"),
3765 (PipelineStageFlags2::ALL_COMMANDS.0, "ALL_COMMANDS"),
3766 (PipelineStageFlags2::COPY.0, "COPY"),
3767 (PipelineStageFlags2::RESOLVE.0, "RESOLVE"),
3768 (PipelineStageFlags2::BLIT.0, "BLIT"),
3769 (PipelineStageFlags2::CLEAR.0, "CLEAR"),
3770 (PipelineStageFlags2::INDEX_INPUT.0, "INDEX_INPUT"),
3771 (
3772 PipelineStageFlags2::VERTEX_ATTRIBUTE_INPUT.0,
3773 "VERTEX_ATTRIBUTE_INPUT",
3774 ),
3775 (
3776 PipelineStageFlags2::PRE_RASTERIZATION_SHADERS.0,
3777 "PRE_RASTERIZATION_SHADERS",
3778 ),
3779 (PipelineStageFlags2::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"),
3780 (PipelineStageFlags2::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"),
3781 (
3782 PipelineStageFlags2::TRANSFORM_FEEDBACK_EXT.0,
3783 "TRANSFORM_FEEDBACK_EXT",
3784 ),
3785 (
3786 PipelineStageFlags2::CONDITIONAL_RENDERING_EXT.0,
3787 "CONDITIONAL_RENDERING_EXT",
3788 ),
3789 (
3790 PipelineStageFlags2::COMMAND_PREPROCESS_NV.0,
3791 "COMMAND_PREPROCESS_NV",
3792 ),
3793 (
3794 PipelineStageFlags2::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0,
3795 "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR",
3796 ),
3797 (
3798 PipelineStageFlags2::ACCELERATION_STRUCTURE_BUILD_KHR.0,
3799 "ACCELERATION_STRUCTURE_BUILD_KHR",
3800 ),
3801 (
3802 PipelineStageFlags2::RAY_TRACING_SHADER_KHR.0,
3803 "RAY_TRACING_SHADER_KHR",
3804 ),
3805 (
3806 PipelineStageFlags2::FRAGMENT_DENSITY_PROCESS_EXT.0,
3807 "FRAGMENT_DENSITY_PROCESS_EXT",
3808 ),
3809 (PipelineStageFlags2::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"),
3810 (PipelineStageFlags2::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"),
3811 (
3812 PipelineStageFlags2::SUBPASS_SHADING_HUAWEI.0,
3813 "SUBPASS_SHADING_HUAWEI",
3814 ),
3815 (
3816 PipelineStageFlags2::INVOCATION_MASK_HUAWEI.0,
3817 "INVOCATION_MASK_HUAWEI",
3818 ),
3819 (
3820 PipelineStageFlags2::ACCELERATION_STRUCTURE_COPY_KHR.0,
3821 "ACCELERATION_STRUCTURE_COPY_KHR",
3822 ),
3823 (
3824 PipelineStageFlags2::MICROMAP_BUILD_EXT.0,
3825 "MICROMAP_BUILD_EXT",
3826 ),
3827 (
3828 PipelineStageFlags2::CLUSTER_CULLING_SHADER_HUAWEI.0,
3829 "CLUSTER_CULLING_SHADER_HUAWEI",
3830 ),
3831 (PipelineStageFlags2::RESERVED_43_ARM.0, "RESERVED_43_ARM"),
3832 (PipelineStageFlags2::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"),
3833 (PipelineStageFlags2::RESERVED_42_EXT.0, "RESERVED_42_EXT"),
3834 ];
3835 debug_flags(f, KNOWN, self.0)
3836 }
3837}
3838impl fmt::Debug for PipelineTessellationStateCreateFlags {
3839 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3840 const KNOWN: &[(Flags, &str)] = &[];
3841 debug_flags(f, KNOWN, self.0)
3842 }
3843}
3844impl fmt::Debug for PipelineVertexInputStateCreateFlags {
3845 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3846 const KNOWN: &[(Flags, &str)] = &[];
3847 debug_flags(f, KNOWN, self.0)
3848 }
3849}
3850impl fmt::Debug for PipelineViewportStateCreateFlags {
3851 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3852 const KNOWN: &[(Flags, &str)] = &[];
3853 debug_flags(f, KNOWN, self.0)
3854 }
3855}
3856impl fmt::Debug for PipelineViewportSwizzleStateCreateFlagsNV {
3857 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3858 const KNOWN: &[(Flags, &str)] = &[];
3859 debug_flags(f, KNOWN, self.0)
3860 }
3861}
3862impl fmt::Debug for PointClippingBehavior {
3863 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3864 let name = match *self {
3865 Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"),
3866 Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"),
3867 _ => None,
3868 };
3869 if let Some(x) = name {
3870 f.write_str(x)
3871 } else {
3872 self.0.fmt(f)
3873 }
3874 }
3875}
3876impl fmt::Debug for PolygonMode {
3877 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3878 let name = match *self {
3879 Self::FILL => Some("FILL"),
3880 Self::LINE => Some("LINE"),
3881 Self::POINT => Some("POINT"),
3882 Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"),
3883 _ => None,
3884 };
3885 if let Some(x) = name {
3886 f.write_str(x)
3887 } else {
3888 self.0.fmt(f)
3889 }
3890 }
3891}
3892impl fmt::Debug for PresentGravityFlagsEXT {
3893 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3894 const KNOWN: &[(Flags, &str)] = &[
3895 (PresentGravityFlagsEXT::MIN.0, "MIN"),
3896 (PresentGravityFlagsEXT::MAX.0, "MAX"),
3897 (PresentGravityFlagsEXT::CENTERED.0, "CENTERED"),
3898 ];
3899 debug_flags(f, KNOWN, self.0)
3900 }
3901}
3902impl fmt::Debug for PresentModeKHR {
3903 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3904 let name = match *self {
3905 Self::IMMEDIATE => Some("IMMEDIATE"),
3906 Self::MAILBOX => Some("MAILBOX"),
3907 Self::FIFO => Some("FIFO"),
3908 Self::FIFO_RELAXED => Some("FIFO_RELAXED"),
3909 Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"),
3910 Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"),
3911 _ => None,
3912 };
3913 if let Some(x) = name {
3914 f.write_str(x)
3915 } else {
3916 self.0.fmt(f)
3917 }
3918 }
3919}
3920impl fmt::Debug for PresentScalingFlagsEXT {
3921 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3922 const KNOWN: &[(Flags, &str)] = &[
3923 (PresentScalingFlagsEXT::ONE_TO_ONE.0, "ONE_TO_ONE"),
3924 (
3925 PresentScalingFlagsEXT::ASPECT_RATIO_STRETCH.0,
3926 "ASPECT_RATIO_STRETCH",
3927 ),
3928 (PresentScalingFlagsEXT::STRETCH.0, "STRETCH"),
3929 ];
3930 debug_flags(f, KNOWN, self.0)
3931 }
3932}
3933impl fmt::Debug for PrimitiveTopology {
3934 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3935 let name = match *self {
3936 Self::POINT_LIST => Some("POINT_LIST"),
3937 Self::LINE_LIST => Some("LINE_LIST"),
3938 Self::LINE_STRIP => Some("LINE_STRIP"),
3939 Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"),
3940 Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"),
3941 Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"),
3942 Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"),
3943 Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"),
3944 Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"),
3945 Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"),
3946 Self::PATCH_LIST => Some("PATCH_LIST"),
3947 _ => None,
3948 };
3949 if let Some(x) = name {
3950 f.write_str(x)
3951 } else {
3952 self.0.fmt(f)
3953 }
3954 }
3955}
3956impl fmt::Debug for PrivateDataSlotCreateFlags {
3957 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3958 const KNOWN: &[(Flags, &str)] =
3959 &[(PrivateDataSlotCreateFlags::RESERVED_0_NV.0, "RESERVED_0_NV")];
3960 debug_flags(f, KNOWN, self.0)
3961 }
3962}
3963impl fmt::Debug for ProvokingVertexModeEXT {
3964 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3965 let name = match *self {
3966 Self::FIRST_VERTEX => Some("FIRST_VERTEX"),
3967 Self::LAST_VERTEX => Some("LAST_VERTEX"),
3968 _ => None,
3969 };
3970 if let Some(x) = name {
3971 f.write_str(x)
3972 } else {
3973 self.0.fmt(f)
3974 }
3975 }
3976}
3977impl fmt::Debug for QueryControlFlags {
3978 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3979 const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")];
3980 debug_flags(f, KNOWN, self.0)
3981 }
3982}
3983impl fmt::Debug for QueryPipelineStatisticFlags {
3984 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3985 const KNOWN: &[(Flags, &str)] = &[
3986 (
3987 QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0,
3988 "INPUT_ASSEMBLY_VERTICES",
3989 ),
3990 (
3991 QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0,
3992 "INPUT_ASSEMBLY_PRIMITIVES",
3993 ),
3994 (
3995 QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0,
3996 "VERTEX_SHADER_INVOCATIONS",
3997 ),
3998 (
3999 QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0,
4000 "GEOMETRY_SHADER_INVOCATIONS",
4001 ),
4002 (
4003 QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0,
4004 "GEOMETRY_SHADER_PRIMITIVES",
4005 ),
4006 (
4007 QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0,
4008 "CLIPPING_INVOCATIONS",
4009 ),
4010 (
4011 QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0,
4012 "CLIPPING_PRIMITIVES",
4013 ),
4014 (
4015 QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0,
4016 "FRAGMENT_SHADER_INVOCATIONS",
4017 ),
4018 (
4019 QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0,
4020 "TESSELLATION_CONTROL_SHADER_PATCHES",
4021 ),
4022 (
4023 QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0,
4024 "TESSELLATION_EVALUATION_SHADER_INVOCATIONS",
4025 ),
4026 (
4027 QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0,
4028 "COMPUTE_SHADER_INVOCATIONS",
4029 ),
4030 (
4031 QueryPipelineStatisticFlags::TASK_SHADER_INVOCATIONS_EXT.0,
4032 "TASK_SHADER_INVOCATIONS_EXT",
4033 ),
4034 (
4035 QueryPipelineStatisticFlags::MESH_SHADER_INVOCATIONS_EXT.0,
4036 "MESH_SHADER_INVOCATIONS_EXT",
4037 ),
4038 (
4039 QueryPipelineStatisticFlags::CLUSTER_CULLING_SHADER_INVOCATIONS_HUAWEI.0,
4040 "CLUSTER_CULLING_SHADER_INVOCATIONS_HUAWEI",
4041 ),
4042 ];
4043 debug_flags(f, KNOWN, self.0)
4044 }
4045}
4046impl fmt::Debug for QueryPoolCreateFlags {
4047 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4048 const KNOWN: &[(Flags, &str)] = &[];
4049 debug_flags(f, KNOWN, self.0)
4050 }
4051}
4052impl fmt::Debug for QueryPoolSamplingModeINTEL {
4053 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4054 let name = match *self {
4055 Self::MANUAL => Some("MANUAL"),
4056 _ => None,
4057 };
4058 if let Some(x) = name {
4059 f.write_str(x)
4060 } else {
4061 self.0.fmt(f)
4062 }
4063 }
4064}
4065impl fmt::Debug for QueryResultFlags {
4066 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4067 const KNOWN: &[(Flags, &str)] = &[
4068 (QueryResultFlags::TYPE_64.0, "TYPE_64"),
4069 (QueryResultFlags::WAIT.0, "WAIT"),
4070 (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"),
4071 (QueryResultFlags::PARTIAL.0, "PARTIAL"),
4072 (QueryResultFlags::WITH_STATUS_KHR.0, "WITH_STATUS_KHR"),
4073 ];
4074 debug_flags(f, KNOWN, self.0)
4075 }
4076}
4077impl fmt::Debug for QueryResultStatusKHR {
4078 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4079 let name = match *self {
4080 Self::ERROR => Some("ERROR"),
4081 Self::NOT_READY => Some("NOT_READY"),
4082 Self::COMPLETE => Some("COMPLETE"),
4083 _ => None,
4084 };
4085 if let Some(x) = name {
4086 f.write_str(x)
4087 } else {
4088 self.0.fmt(f)
4089 }
4090 }
4091}
4092impl fmt::Debug for QueryType {
4093 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4094 let name = match *self {
4095 Self::OCCLUSION => Some("OCCLUSION"),
4096 Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"),
4097 Self::TIMESTAMP => Some("TIMESTAMP"),
4098 Self::RESULT_STATUS_ONLY_KHR => Some("RESULT_STATUS_ONLY_KHR"),
4099 Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"),
4100 Self::PERFORMANCE_QUERY_KHR => Some("PERFORMANCE_QUERY_KHR"),
4101 Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR => {
4102 Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR")
4103 }
4104 Self::ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR => {
4105 Some("ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR")
4106 }
4107 Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => {
4108 Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV")
4109 }
4110 Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"),
4111 Self::VIDEO_ENCODE_FEEDBACK_KHR => Some("VIDEO_ENCODE_FEEDBACK_KHR"),
4112 Self::MESH_PRIMITIVES_GENERATED_EXT => Some("MESH_PRIMITIVES_GENERATED_EXT"),
4113 Self::PRIMITIVES_GENERATED_EXT => Some("PRIMITIVES_GENERATED_EXT"),
4114 Self::ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR => {
4115 Some("ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR")
4116 }
4117 Self::ACCELERATION_STRUCTURE_SIZE_KHR => Some("ACCELERATION_STRUCTURE_SIZE_KHR"),
4118 Self::MICROMAP_SERIALIZATION_SIZE_EXT => Some("MICROMAP_SERIALIZATION_SIZE_EXT"),
4119 Self::MICROMAP_COMPACTED_SIZE_EXT => Some("MICROMAP_COMPACTED_SIZE_EXT"),
4120 _ => None,
4121 };
4122 if let Some(x) = name {
4123 f.write_str(x)
4124 } else {
4125 self.0.fmt(f)
4126 }
4127 }
4128}
4129impl fmt::Debug for QueueFlags {
4130 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4131 const KNOWN: &[(Flags, &str)] = &[
4132 (QueueFlags::GRAPHICS.0, "GRAPHICS"),
4133 (QueueFlags::COMPUTE.0, "COMPUTE"),
4134 (QueueFlags::TRANSFER.0, "TRANSFER"),
4135 (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"),
4136 (QueueFlags::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"),
4137 (QueueFlags::RESERVED_9_EXT.0, "RESERVED_9_EXT"),
4138 (QueueFlags::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"),
4139 (QueueFlags::RESERVED_7_QCOM.0, "RESERVED_7_QCOM"),
4140 (QueueFlags::RESERVED_11_ARM.0, "RESERVED_11_ARM"),
4141 (QueueFlags::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"),
4142 (QueueFlags::RESERVED_10_EXT.0, "RESERVED_10_EXT"),
4143 (QueueFlags::PROTECTED.0, "PROTECTED"),
4144 ];
4145 debug_flags(f, KNOWN, self.0)
4146 }
4147}
4148impl fmt::Debug for QueueGlobalPriorityKHR {
4149 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4150 let name = match *self {
4151 Self::LOW => Some("LOW"),
4152 Self::MEDIUM => Some("MEDIUM"),
4153 Self::HIGH => Some("HIGH"),
4154 Self::REALTIME => Some("REALTIME"),
4155 _ => None,
4156 };
4157 if let Some(x) = name {
4158 f.write_str(x)
4159 } else {
4160 self.0.fmt(f)
4161 }
4162 }
4163}
4164impl fmt::Debug for RasterizationOrderAMD {
4165 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4166 let name = match *self {
4167 Self::STRICT => Some("STRICT"),
4168 Self::RELAXED => Some("RELAXED"),
4169 _ => None,
4170 };
4171 if let Some(x) = name {
4172 f.write_str(x)
4173 } else {
4174 self.0.fmt(f)
4175 }
4176 }
4177}
4178impl fmt::Debug for RayTracingInvocationReorderModeNV {
4179 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4180 let name = match *self {
4181 Self::NONE => Some("NONE"),
4182 Self::REORDER => Some("REORDER"),
4183 _ => None,
4184 };
4185 if let Some(x) = name {
4186 f.write_str(x)
4187 } else {
4188 self.0.fmt(f)
4189 }
4190 }
4191}
4192impl fmt::Debug for RayTracingShaderGroupTypeKHR {
4193 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4194 let name = match *self {
4195 Self::GENERAL => Some("GENERAL"),
4196 Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"),
4197 Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"),
4198 _ => None,
4199 };
4200 if let Some(x) = name {
4201 f.write_str(x)
4202 } else {
4203 self.0.fmt(f)
4204 }
4205 }
4206}
4207impl fmt::Debug for RenderPassCreateFlags {
4208 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4209 const KNOWN: &[(Flags, &str)] = &[
4210 (RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR"),
4211 (RenderPassCreateFlags::TRANSFORM_QCOM.0, "TRANSFORM_QCOM"),
4212 ];
4213 debug_flags(f, KNOWN, self.0)
4214 }
4215}
4216impl fmt::Debug for RenderingFlags {
4217 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4218 const KNOWN: &[(Flags, &str)] = &[
4219 (
4220 RenderingFlags::CONTENTS_SECONDARY_COMMAND_BUFFERS.0,
4221 "CONTENTS_SECONDARY_COMMAND_BUFFERS",
4222 ),
4223 (RenderingFlags::SUSPENDING.0, "SUSPENDING"),
4224 (RenderingFlags::RESUMING.0, "RESUMING"),
4225 (
4226 RenderingFlags::ENABLE_LEGACY_DITHERING_EXT.0,
4227 "ENABLE_LEGACY_DITHERING_EXT",
4228 ),
4229 ];
4230 debug_flags(f, KNOWN, self.0)
4231 }
4232}
4233impl fmt::Debug for ResolveModeFlags {
4234 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4235 const KNOWN: &[(Flags, &str)] = &[
4236 (ResolveModeFlags::NONE.0, "NONE"),
4237 (ResolveModeFlags::SAMPLE_ZERO.0, "SAMPLE_ZERO"),
4238 (ResolveModeFlags::AVERAGE.0, "AVERAGE"),
4239 (ResolveModeFlags::MIN.0, "MIN"),
4240 (ResolveModeFlags::MAX.0, "MAX"),
4241 (
4242 ResolveModeFlags::EXTENSION_469_FLAG_0.0,
4243 "EXTENSION_469_FLAG_0",
4244 ),
4245 ];
4246 debug_flags(f, KNOWN, self.0)
4247 }
4248}
4249impl fmt::Debug for SampleCountFlags {
4250 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4251 const KNOWN: &[(Flags, &str)] = &[
4252 (SampleCountFlags::TYPE_1.0, "TYPE_1"),
4253 (SampleCountFlags::TYPE_2.0, "TYPE_2"),
4254 (SampleCountFlags::TYPE_4.0, "TYPE_4"),
4255 (SampleCountFlags::TYPE_8.0, "TYPE_8"),
4256 (SampleCountFlags::TYPE_16.0, "TYPE_16"),
4257 (SampleCountFlags::TYPE_32.0, "TYPE_32"),
4258 (SampleCountFlags::TYPE_64.0, "TYPE_64"),
4259 ];
4260 debug_flags(f, KNOWN, self.0)
4261 }
4262}
4263impl fmt::Debug for SamplerAddressMode {
4264 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4265 let name = match *self {
4266 Self::REPEAT => Some("REPEAT"),
4267 Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"),
4268 Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"),
4269 Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"),
4270 Self::MIRROR_CLAMP_TO_EDGE => Some("MIRROR_CLAMP_TO_EDGE"),
4271 _ => None,
4272 };
4273 if let Some(x) = name {
4274 f.write_str(x)
4275 } else {
4276 self.0.fmt(f)
4277 }
4278 }
4279}
4280impl fmt::Debug for SamplerCreateFlags {
4281 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4282 const KNOWN: &[(Flags, &str)] = &[
4283 (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"),
4284 (
4285 SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0,
4286 "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT",
4287 ),
4288 (
4289 SamplerCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
4290 "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
4291 ),
4292 (
4293 SamplerCreateFlags::NON_SEAMLESS_CUBE_MAP_EXT.0,
4294 "NON_SEAMLESS_CUBE_MAP_EXT",
4295 ),
4296 (
4297 SamplerCreateFlags::IMAGE_PROCESSING_QCOM.0,
4298 "IMAGE_PROCESSING_QCOM",
4299 ),
4300 ];
4301 debug_flags(f, KNOWN, self.0)
4302 }
4303}
4304impl fmt::Debug for SamplerMipmapMode {
4305 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4306 let name = match *self {
4307 Self::NEAREST => Some("NEAREST"),
4308 Self::LINEAR => Some("LINEAR"),
4309 _ => None,
4310 };
4311 if let Some(x) = name {
4312 f.write_str(x)
4313 } else {
4314 self.0.fmt(f)
4315 }
4316 }
4317}
4318impl fmt::Debug for SamplerReductionMode {
4319 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4320 let name = match *self {
4321 Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"),
4322 Self::MIN => Some("MIN"),
4323 Self::MAX => Some("MAX"),
4324 _ => None,
4325 };
4326 if let Some(x) = name {
4327 f.write_str(x)
4328 } else {
4329 self.0.fmt(f)
4330 }
4331 }
4332}
4333impl fmt::Debug for SamplerYcbcrModelConversion {
4334 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4335 let name = match *self {
4336 Self::RGB_IDENTITY => Some("RGB_IDENTITY"),
4337 Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"),
4338 Self::YCBCR_709 => Some("YCBCR_709"),
4339 Self::YCBCR_601 => Some("YCBCR_601"),
4340 Self::YCBCR_2020 => Some("YCBCR_2020"),
4341 _ => None,
4342 };
4343 if let Some(x) = name {
4344 f.write_str(x)
4345 } else {
4346 self.0.fmt(f)
4347 }
4348 }
4349}
4350impl fmt::Debug for SamplerYcbcrRange {
4351 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4352 let name = match *self {
4353 Self::ITU_FULL => Some("ITU_FULL"),
4354 Self::ITU_NARROW => Some("ITU_NARROW"),
4355 _ => None,
4356 };
4357 if let Some(x) = name {
4358 f.write_str(x)
4359 } else {
4360 self.0.fmt(f)
4361 }
4362 }
4363}
4364impl fmt::Debug for ScopeNV {
4365 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4366 let name = match *self {
4367 Self::DEVICE => Some("DEVICE"),
4368 Self::WORKGROUP => Some("WORKGROUP"),
4369 Self::SUBGROUP => Some("SUBGROUP"),
4370 Self::QUEUE_FAMILY => Some("QUEUE_FAMILY"),
4371 _ => None,
4372 };
4373 if let Some(x) = name {
4374 f.write_str(x)
4375 } else {
4376 self.0.fmt(f)
4377 }
4378 }
4379}
4380impl fmt::Debug for ScreenSurfaceCreateFlagsQNX {
4381 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4382 const KNOWN: &[(Flags, &str)] = &[];
4383 debug_flags(f, KNOWN, self.0)
4384 }
4385}
4386impl fmt::Debug for SemaphoreCreateFlags {
4387 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4388 const KNOWN: &[(Flags, &str)] = &[];
4389 debug_flags(f, KNOWN, self.0)
4390 }
4391}
4392impl fmt::Debug for SemaphoreImportFlags {
4393 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4394 const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")];
4395 debug_flags(f, KNOWN, self.0)
4396 }
4397}
4398impl fmt::Debug for SemaphoreType {
4399 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4400 let name = match *self {
4401 Self::BINARY => Some("BINARY"),
4402 Self::TIMELINE => Some("TIMELINE"),
4403 _ => None,
4404 };
4405 if let Some(x) = name {
4406 f.write_str(x)
4407 } else {
4408 self.0.fmt(f)
4409 }
4410 }
4411}
4412impl fmt::Debug for SemaphoreWaitFlags {
4413 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4414 const KNOWN: &[(Flags, &str)] = &[(SemaphoreWaitFlags::ANY.0, "ANY")];
4415 debug_flags(f, KNOWN, self.0)
4416 }
4417}
4418impl fmt::Debug for ShaderCodeTypeEXT {
4419 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4420 let name = match *self {
4421 Self::BINARY => Some("BINARY"),
4422 Self::SPIRV => Some("SPIRV"),
4423 _ => None,
4424 };
4425 if let Some(x) = name {
4426 f.write_str(x)
4427 } else {
4428 self.0.fmt(f)
4429 }
4430 }
4431}
4432impl fmt::Debug for ShaderCorePropertiesFlagsAMD {
4433 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4434 const KNOWN: &[(Flags, &str)] = &[];
4435 debug_flags(f, KNOWN, self.0)
4436 }
4437}
4438impl fmt::Debug for ShaderCreateFlagsEXT {
4439 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4440 const KNOWN: &[(Flags, &str)] = &[
4441 (ShaderCreateFlagsEXT::LINK_STAGE.0, "LINK_STAGE"),
4442 (
4443 ShaderCreateFlagsEXT::ALLOW_VARYING_SUBGROUP_SIZE.0,
4444 "ALLOW_VARYING_SUBGROUP_SIZE",
4445 ),
4446 (
4447 ShaderCreateFlagsEXT::REQUIRE_FULL_SUBGROUPS.0,
4448 "REQUIRE_FULL_SUBGROUPS",
4449 ),
4450 (ShaderCreateFlagsEXT::NO_TASK_SHADER.0, "NO_TASK_SHADER"),
4451 (ShaderCreateFlagsEXT::DISPATCH_BASE.0, "DISPATCH_BASE"),
4452 (
4453 ShaderCreateFlagsEXT::FRAGMENT_SHADING_RATE_ATTACHMENT.0,
4454 "FRAGMENT_SHADING_RATE_ATTACHMENT",
4455 ),
4456 (
4457 ShaderCreateFlagsEXT::FRAGMENT_DENSITY_MAP_ATTACHMENT.0,
4458 "FRAGMENT_DENSITY_MAP_ATTACHMENT",
4459 ),
4460 ];
4461 debug_flags(f, KNOWN, self.0)
4462 }
4463}
4464impl fmt::Debug for ShaderFloatControlsIndependence {
4465 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4466 let name = match *self {
4467 Self::TYPE_32_ONLY => Some("TYPE_32_ONLY"),
4468 Self::ALL => Some("ALL"),
4469 Self::NONE => Some("NONE"),
4470 _ => None,
4471 };
4472 if let Some(x) = name {
4473 f.write_str(x)
4474 } else {
4475 self.0.fmt(f)
4476 }
4477 }
4478}
4479impl fmt::Debug for ShaderGroupShaderKHR {
4480 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4481 let name = match *self {
4482 Self::GENERAL => Some("GENERAL"),
4483 Self::CLOSEST_HIT => Some("CLOSEST_HIT"),
4484 Self::ANY_HIT => Some("ANY_HIT"),
4485 Self::INTERSECTION => Some("INTERSECTION"),
4486 _ => None,
4487 };
4488 if let Some(x) = name {
4489 f.write_str(x)
4490 } else {
4491 self.0.fmt(f)
4492 }
4493 }
4494}
4495impl fmt::Debug for ShaderInfoTypeAMD {
4496 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4497 let name = match *self {
4498 Self::STATISTICS => Some("STATISTICS"),
4499 Self::BINARY => Some("BINARY"),
4500 Self::DISASSEMBLY => Some("DISASSEMBLY"),
4501 _ => None,
4502 };
4503 if let Some(x) = name {
4504 f.write_str(x)
4505 } else {
4506 self.0.fmt(f)
4507 }
4508 }
4509}
4510impl fmt::Debug for ShaderModuleCreateFlags {
4511 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4512 const KNOWN: &[(Flags, &str)] = &[];
4513 debug_flags(f, KNOWN, self.0)
4514 }
4515}
4516impl fmt::Debug for ShaderStageFlags {
4517 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4518 const KNOWN: &[(Flags, &str)] = &[
4519 (ShaderStageFlags::VERTEX.0, "VERTEX"),
4520 (
4521 ShaderStageFlags::TESSELLATION_CONTROL.0,
4522 "TESSELLATION_CONTROL",
4523 ),
4524 (
4525 ShaderStageFlags::TESSELLATION_EVALUATION.0,
4526 "TESSELLATION_EVALUATION",
4527 ),
4528 (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"),
4529 (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"),
4530 (ShaderStageFlags::COMPUTE.0, "COMPUTE"),
4531 (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"),
4532 (ShaderStageFlags::ALL.0, "ALL"),
4533 (ShaderStageFlags::RAYGEN_KHR.0, "RAYGEN_KHR"),
4534 (ShaderStageFlags::ANY_HIT_KHR.0, "ANY_HIT_KHR"),
4535 (ShaderStageFlags::CLOSEST_HIT_KHR.0, "CLOSEST_HIT_KHR"),
4536 (ShaderStageFlags::MISS_KHR.0, "MISS_KHR"),
4537 (ShaderStageFlags::INTERSECTION_KHR.0, "INTERSECTION_KHR"),
4538 (ShaderStageFlags::CALLABLE_KHR.0, "CALLABLE_KHR"),
4539 (ShaderStageFlags::TASK_EXT.0, "TASK_EXT"),
4540 (ShaderStageFlags::MESH_EXT.0, "MESH_EXT"),
4541 (
4542 ShaderStageFlags::SUBPASS_SHADING_HUAWEI.0,
4543 "SUBPASS_SHADING_HUAWEI",
4544 ),
4545 (
4546 ShaderStageFlags::CLUSTER_CULLING_HUAWEI.0,
4547 "CLUSTER_CULLING_HUAWEI",
4548 ),
4549 ];
4550 debug_flags(f, KNOWN, self.0)
4551 }
4552}
4553impl fmt::Debug for ShadingRatePaletteEntryNV {
4554 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4555 let name = match *self {
4556 Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"),
4557 Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"),
4558 Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"),
4559 Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"),
4560 Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"),
4561 Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"),
4562 Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"),
4563 Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"),
4564 Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"),
4565 Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"),
4566 Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"),
4567 Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"),
4568 _ => None,
4569 };
4570 if let Some(x) = name {
4571 f.write_str(x)
4572 } else {
4573 self.0.fmt(f)
4574 }
4575 }
4576}
4577impl fmt::Debug for SharingMode {
4578 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4579 let name = match *self {
4580 Self::EXCLUSIVE => Some("EXCLUSIVE"),
4581 Self::CONCURRENT => Some("CONCURRENT"),
4582 _ => None,
4583 };
4584 if let Some(x) = name {
4585 f.write_str(x)
4586 } else {
4587 self.0.fmt(f)
4588 }
4589 }
4590}
4591impl fmt::Debug for SparseImageFormatFlags {
4592 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4593 const KNOWN: &[(Flags, &str)] = &[
4594 (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"),
4595 (
4596 SparseImageFormatFlags::ALIGNED_MIP_SIZE.0,
4597 "ALIGNED_MIP_SIZE",
4598 ),
4599 (
4600 SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0,
4601 "NONSTANDARD_BLOCK_SIZE",
4602 ),
4603 ];
4604 debug_flags(f, KNOWN, self.0)
4605 }
4606}
4607impl fmt::Debug for SparseMemoryBindFlags {
4608 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4609 const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")];
4610 debug_flags(f, KNOWN, self.0)
4611 }
4612}
4613impl fmt::Debug for StencilFaceFlags {
4614 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4615 const KNOWN: &[(Flags, &str)] = &[
4616 (StencilFaceFlags::FRONT.0, "FRONT"),
4617 (StencilFaceFlags::BACK.0, "BACK"),
4618 (StencilFaceFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"),
4619 ];
4620 debug_flags(f, KNOWN, self.0)
4621 }
4622}
4623impl fmt::Debug for StencilOp {
4624 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4625 let name = match *self {
4626 Self::KEEP => Some("KEEP"),
4627 Self::ZERO => Some("ZERO"),
4628 Self::REPLACE => Some("REPLACE"),
4629 Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"),
4630 Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"),
4631 Self::INVERT => Some("INVERT"),
4632 Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"),
4633 Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"),
4634 _ => None,
4635 };
4636 if let Some(x) = name {
4637 f.write_str(x)
4638 } else {
4639 self.0.fmt(f)
4640 }
4641 }
4642}
4643impl fmt::Debug for StreamDescriptorSurfaceCreateFlagsGGP {
4644 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4645 const KNOWN: &[(Flags, &str)] = &[];
4646 debug_flags(f, KNOWN, self.0)
4647 }
4648}
4649impl fmt::Debug for StructureType {
4650 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4651 let name = match *self {
4652 Self::APPLICATION_INFO => Some("APPLICATION_INFO"),
4653 Self::INSTANCE_CREATE_INFO => Some("INSTANCE_CREATE_INFO"),
4654 Self::DEVICE_QUEUE_CREATE_INFO => Some("DEVICE_QUEUE_CREATE_INFO"),
4655 Self::DEVICE_CREATE_INFO => Some("DEVICE_CREATE_INFO"),
4656 Self::SUBMIT_INFO => Some("SUBMIT_INFO"),
4657 Self::MEMORY_ALLOCATE_INFO => Some("MEMORY_ALLOCATE_INFO"),
4658 Self::MAPPED_MEMORY_RANGE => Some("MAPPED_MEMORY_RANGE"),
4659 Self::BIND_SPARSE_INFO => Some("BIND_SPARSE_INFO"),
4660 Self::FENCE_CREATE_INFO => Some("FENCE_CREATE_INFO"),
4661 Self::SEMAPHORE_CREATE_INFO => Some("SEMAPHORE_CREATE_INFO"),
4662 Self::EVENT_CREATE_INFO => Some("EVENT_CREATE_INFO"),
4663 Self::QUERY_POOL_CREATE_INFO => Some("QUERY_POOL_CREATE_INFO"),
4664 Self::BUFFER_CREATE_INFO => Some("BUFFER_CREATE_INFO"),
4665 Self::BUFFER_VIEW_CREATE_INFO => Some("BUFFER_VIEW_CREATE_INFO"),
4666 Self::IMAGE_CREATE_INFO => Some("IMAGE_CREATE_INFO"),
4667 Self::IMAGE_VIEW_CREATE_INFO => Some("IMAGE_VIEW_CREATE_INFO"),
4668 Self::SHADER_MODULE_CREATE_INFO => Some("SHADER_MODULE_CREATE_INFO"),
4669 Self::PIPELINE_CACHE_CREATE_INFO => Some("PIPELINE_CACHE_CREATE_INFO"),
4670 Self::PIPELINE_SHADER_STAGE_CREATE_INFO => Some("PIPELINE_SHADER_STAGE_CREATE_INFO"),
4671 Self::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => {
4672 Some("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO")
4673 }
4674 Self::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => {
4675 Some("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO")
4676 }
4677 Self::PIPELINE_TESSELLATION_STATE_CREATE_INFO => {
4678 Some("PIPELINE_TESSELLATION_STATE_CREATE_INFO")
4679 }
4680 Self::PIPELINE_VIEWPORT_STATE_CREATE_INFO => {
4681 Some("PIPELINE_VIEWPORT_STATE_CREATE_INFO")
4682 }
4683 Self::PIPELINE_RASTERIZATION_STATE_CREATE_INFO => {
4684 Some("PIPELINE_RASTERIZATION_STATE_CREATE_INFO")
4685 }
4686 Self::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => {
4687 Some("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO")
4688 }
4689 Self::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => {
4690 Some("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO")
4691 }
4692 Self::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => {
4693 Some("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO")
4694 }
4695 Self::PIPELINE_DYNAMIC_STATE_CREATE_INFO => Some("PIPELINE_DYNAMIC_STATE_CREATE_INFO"),
4696 Self::GRAPHICS_PIPELINE_CREATE_INFO => Some("GRAPHICS_PIPELINE_CREATE_INFO"),
4697 Self::COMPUTE_PIPELINE_CREATE_INFO => Some("COMPUTE_PIPELINE_CREATE_INFO"),
4698 Self::PIPELINE_LAYOUT_CREATE_INFO => Some("PIPELINE_LAYOUT_CREATE_INFO"),
4699 Self::SAMPLER_CREATE_INFO => Some("SAMPLER_CREATE_INFO"),
4700 Self::DESCRIPTOR_SET_LAYOUT_CREATE_INFO => Some("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"),
4701 Self::DESCRIPTOR_POOL_CREATE_INFO => Some("DESCRIPTOR_POOL_CREATE_INFO"),
4702 Self::DESCRIPTOR_SET_ALLOCATE_INFO => Some("DESCRIPTOR_SET_ALLOCATE_INFO"),
4703 Self::WRITE_DESCRIPTOR_SET => Some("WRITE_DESCRIPTOR_SET"),
4704 Self::COPY_DESCRIPTOR_SET => Some("COPY_DESCRIPTOR_SET"),
4705 Self::FRAMEBUFFER_CREATE_INFO => Some("FRAMEBUFFER_CREATE_INFO"),
4706 Self::RENDER_PASS_CREATE_INFO => Some("RENDER_PASS_CREATE_INFO"),
4707 Self::COMMAND_POOL_CREATE_INFO => Some("COMMAND_POOL_CREATE_INFO"),
4708 Self::COMMAND_BUFFER_ALLOCATE_INFO => Some("COMMAND_BUFFER_ALLOCATE_INFO"),
4709 Self::COMMAND_BUFFER_INHERITANCE_INFO => Some("COMMAND_BUFFER_INHERITANCE_INFO"),
4710 Self::COMMAND_BUFFER_BEGIN_INFO => Some("COMMAND_BUFFER_BEGIN_INFO"),
4711 Self::RENDER_PASS_BEGIN_INFO => Some("RENDER_PASS_BEGIN_INFO"),
4712 Self::BUFFER_MEMORY_BARRIER => Some("BUFFER_MEMORY_BARRIER"),
4713 Self::IMAGE_MEMORY_BARRIER => Some("IMAGE_MEMORY_BARRIER"),
4714 Self::MEMORY_BARRIER => Some("MEMORY_BARRIER"),
4715 Self::LOADER_INSTANCE_CREATE_INFO => Some("LOADER_INSTANCE_CREATE_INFO"),
4716 Self::LOADER_DEVICE_CREATE_INFO => Some("LOADER_DEVICE_CREATE_INFO"),
4717 Self::SWAPCHAIN_CREATE_INFO_KHR => Some("SWAPCHAIN_CREATE_INFO_KHR"),
4718 Self::PRESENT_INFO_KHR => Some("PRESENT_INFO_KHR"),
4719 Self::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR => {
4720 Some("DEVICE_GROUP_PRESENT_CAPABILITIES_KHR")
4721 }
4722 Self::IMAGE_SWAPCHAIN_CREATE_INFO_KHR => Some("IMAGE_SWAPCHAIN_CREATE_INFO_KHR"),
4723 Self::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR => {
4724 Some("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR")
4725 }
4726 Self::ACQUIRE_NEXT_IMAGE_INFO_KHR => Some("ACQUIRE_NEXT_IMAGE_INFO_KHR"),
4727 Self::DEVICE_GROUP_PRESENT_INFO_KHR => Some("DEVICE_GROUP_PRESENT_INFO_KHR"),
4728 Self::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR => {
4729 Some("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR")
4730 }
4731 Self::DISPLAY_MODE_CREATE_INFO_KHR => Some("DISPLAY_MODE_CREATE_INFO_KHR"),
4732 Self::DISPLAY_SURFACE_CREATE_INFO_KHR => Some("DISPLAY_SURFACE_CREATE_INFO_KHR"),
4733 Self::DISPLAY_PRESENT_INFO_KHR => Some("DISPLAY_PRESENT_INFO_KHR"),
4734 Self::XLIB_SURFACE_CREATE_INFO_KHR => Some("XLIB_SURFACE_CREATE_INFO_KHR"),
4735 Self::XCB_SURFACE_CREATE_INFO_KHR => Some("XCB_SURFACE_CREATE_INFO_KHR"),
4736 Self::WAYLAND_SURFACE_CREATE_INFO_KHR => Some("WAYLAND_SURFACE_CREATE_INFO_KHR"),
4737 Self::ANDROID_SURFACE_CREATE_INFO_KHR => Some("ANDROID_SURFACE_CREATE_INFO_KHR"),
4738 Self::WIN32_SURFACE_CREATE_INFO_KHR => Some("WIN32_SURFACE_CREATE_INFO_KHR"),
4739 Self::NATIVE_BUFFER_ANDROID => Some("NATIVE_BUFFER_ANDROID"),
4740 Self::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID => {
4741 Some("SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID")
4742 }
4743 Self::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID => {
4744 Some("PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID")
4745 }
4746 Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT => {
4747 Some("DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT")
4748 }
4749 Self::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD => {
4750 Some("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD")
4751 }
4752 Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => Some("DEBUG_MARKER_OBJECT_NAME_INFO_EXT"),
4753 Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => Some("DEBUG_MARKER_OBJECT_TAG_INFO_EXT"),
4754 Self::DEBUG_MARKER_MARKER_INFO_EXT => Some("DEBUG_MARKER_MARKER_INFO_EXT"),
4755 Self::VIDEO_PROFILE_INFO_KHR => Some("VIDEO_PROFILE_INFO_KHR"),
4756 Self::VIDEO_CAPABILITIES_KHR => Some("VIDEO_CAPABILITIES_KHR"),
4757 Self::VIDEO_PICTURE_RESOURCE_INFO_KHR => Some("VIDEO_PICTURE_RESOURCE_INFO_KHR"),
4758 Self::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR => {
4759 Some("VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR")
4760 }
4761 Self::BIND_VIDEO_SESSION_MEMORY_INFO_KHR => Some("BIND_VIDEO_SESSION_MEMORY_INFO_KHR"),
4762 Self::VIDEO_SESSION_CREATE_INFO_KHR => Some("VIDEO_SESSION_CREATE_INFO_KHR"),
4763 Self::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR => {
4764 Some("VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR")
4765 }
4766 Self::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR => {
4767 Some("VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR")
4768 }
4769 Self::VIDEO_BEGIN_CODING_INFO_KHR => Some("VIDEO_BEGIN_CODING_INFO_KHR"),
4770 Self::VIDEO_END_CODING_INFO_KHR => Some("VIDEO_END_CODING_INFO_KHR"),
4771 Self::VIDEO_CODING_CONTROL_INFO_KHR => Some("VIDEO_CODING_CONTROL_INFO_KHR"),
4772 Self::VIDEO_REFERENCE_SLOT_INFO_KHR => Some("VIDEO_REFERENCE_SLOT_INFO_KHR"),
4773 Self::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR => Some("QUEUE_FAMILY_VIDEO_PROPERTIES_KHR"),
4774 Self::VIDEO_PROFILE_LIST_INFO_KHR => Some("VIDEO_PROFILE_LIST_INFO_KHR"),
4775 Self::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR => {
4776 Some("PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR")
4777 }
4778 Self::VIDEO_FORMAT_PROPERTIES_KHR => Some("VIDEO_FORMAT_PROPERTIES_KHR"),
4779 Self::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR => {
4780 Some("QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR")
4781 }
4782 Self::VIDEO_DECODE_INFO_KHR => Some("VIDEO_DECODE_INFO_KHR"),
4783 Self::VIDEO_DECODE_CAPABILITIES_KHR => Some("VIDEO_DECODE_CAPABILITIES_KHR"),
4784 Self::VIDEO_DECODE_USAGE_INFO_KHR => Some("VIDEO_DECODE_USAGE_INFO_KHR"),
4785 Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => {
4786 Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV")
4787 }
4788 Self::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV => {
4789 Some("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV")
4790 }
4791 Self::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV => {
4792 Some("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV")
4793 }
4794 Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT => {
4795 Some("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT")
4796 }
4797 Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT => {
4798 Some("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT")
4799 }
4800 Self::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT => {
4801 Some("PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT")
4802 }
4803 Self::CU_MODULE_CREATE_INFO_NVX => Some("CU_MODULE_CREATE_INFO_NVX"),
4804 Self::CU_FUNCTION_CREATE_INFO_NVX => Some("CU_FUNCTION_CREATE_INFO_NVX"),
4805 Self::CU_LAUNCH_INFO_NVX => Some("CU_LAUNCH_INFO_NVX"),
4806 Self::IMAGE_VIEW_HANDLE_INFO_NVX => Some("IMAGE_VIEW_HANDLE_INFO_NVX"),
4807 Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => Some("IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"),
4808 Self::VIDEO_ENCODE_H264_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H264_CAPABILITIES_EXT"),
4809 Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => {
4810 Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT")
4811 }
4812 Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => {
4813 Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT")
4814 }
4815 Self::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT => {
4816 Some("VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT")
4817 }
4818 Self::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT => {
4819 Some("VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT")
4820 }
4821 Self::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT => {
4822 Some("VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT")
4823 }
4824 Self::VIDEO_ENCODE_H264_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H264_PROFILE_INFO_EXT"),
4825 Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => {
4826 Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT")
4827 }
4828 Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => {
4829 Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT")
4830 }
4831 Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"),
4832 Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => {
4833 Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT")
4834 }
4835 Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => {
4836 Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT")
4837 }
4838 Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => {
4839 Some("VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT")
4840 }
4841 Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => {
4842 Some("VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT")
4843 }
4844 Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT => {
4845 Some("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT")
4846 }
4847 Self::VIDEO_ENCODE_H265_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H265_PROFILE_INFO_EXT"),
4848 Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => {
4849 Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT")
4850 }
4851 Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => {
4852 Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT")
4853 }
4854 Self::VIDEO_DECODE_H264_CAPABILITIES_KHR => Some("VIDEO_DECODE_H264_CAPABILITIES_KHR"),
4855 Self::VIDEO_DECODE_H264_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H264_PICTURE_INFO_KHR"),
4856 Self::VIDEO_DECODE_H264_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H264_PROFILE_INFO_KHR"),
4857 Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR => {
4858 Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR")
4859 }
4860 Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR => {
4861 Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR")
4862 }
4863 Self::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR => {
4864 Some("VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR")
4865 }
4866 Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => {
4867 Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD")
4868 }
4869 Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => {
4870 Some("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR")
4871 }
4872 Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT => {
4873 Some("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT")
4874 }
4875 Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD => Some("ATTACHMENT_SAMPLE_COUNT_INFO_AMD"),
4876 Self::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX => {
4877 Some("MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX")
4878 }
4879 Self::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP => {
4880 Some("STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP")
4881 }
4882 Self::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV => {
4883 Some("PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV")
4884 }
4885 Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV => {
4886 Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV")
4887 }
4888 Self::EXPORT_MEMORY_ALLOCATE_INFO_NV => Some("EXPORT_MEMORY_ALLOCATE_INFO_NV"),
4889 Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"),
4890 Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"),
4891 Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV => {
4892 Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV")
4893 }
4894 Self::VALIDATION_FLAGS_EXT => Some("VALIDATION_FLAGS_EXT"),
4895 Self::VI_SURFACE_CREATE_INFO_NN => Some("VI_SURFACE_CREATE_INFO_NN"),
4896 Self::IMAGE_VIEW_ASTC_DECODE_MODE_EXT => Some("IMAGE_VIEW_ASTC_DECODE_MODE_EXT"),
4897 Self::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT => {
4898 Some("PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT")
4899 }
4900 Self::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT => {
4901 Some("PIPELINE_ROBUSTNESS_CREATE_INFO_EXT")
4902 }
4903 Self::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT => {
4904 Some("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT")
4905 }
4906 Self::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT => {
4907 Some("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT")
4908 }
4909 Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => {
4910 Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR")
4911 }
4912 Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR => {
4913 Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR")
4914 }
4915 Self::MEMORY_WIN32_HANDLE_PROPERTIES_KHR => Some("MEMORY_WIN32_HANDLE_PROPERTIES_KHR"),
4916 Self::MEMORY_GET_WIN32_HANDLE_INFO_KHR => Some("MEMORY_GET_WIN32_HANDLE_INFO_KHR"),
4917 Self::IMPORT_MEMORY_FD_INFO_KHR => Some("IMPORT_MEMORY_FD_INFO_KHR"),
4918 Self::MEMORY_FD_PROPERTIES_KHR => Some("MEMORY_FD_PROPERTIES_KHR"),
4919 Self::MEMORY_GET_FD_INFO_KHR => Some("MEMORY_GET_FD_INFO_KHR"),
4920 Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR => {
4921 Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR")
4922 }
4923 Self::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => {
4924 Some("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR")
4925 }
4926 Self::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => {
4927 Some("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR")
4928 }
4929 Self::D3D12_FENCE_SUBMIT_INFO_KHR => Some("D3D12_FENCE_SUBMIT_INFO_KHR"),
4930 Self::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR => {
4931 Some("SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR")
4932 }
4933 Self::IMPORT_SEMAPHORE_FD_INFO_KHR => Some("IMPORT_SEMAPHORE_FD_INFO_KHR"),
4934 Self::SEMAPHORE_GET_FD_INFO_KHR => Some("SEMAPHORE_GET_FD_INFO_KHR"),
4935 Self::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR => {
4936 Some("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR")
4937 }
4938 Self::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT => {
4939 Some("COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT")
4940 }
4941 Self::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT => {
4942 Some("PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT")
4943 }
4944 Self::CONDITIONAL_RENDERING_BEGIN_INFO_EXT => {
4945 Some("CONDITIONAL_RENDERING_BEGIN_INFO_EXT")
4946 }
4947 Self::PRESENT_REGIONS_KHR => Some("PRESENT_REGIONS_KHR"),
4948 Self::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV => {
4949 Some("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV")
4950 }
4951 Self::SURFACE_CAPABILITIES_2_EXT => Some("SURFACE_CAPABILITIES_2_EXT"),
4952 Self::DISPLAY_POWER_INFO_EXT => Some("DISPLAY_POWER_INFO_EXT"),
4953 Self::DEVICE_EVENT_INFO_EXT => Some("DEVICE_EVENT_INFO_EXT"),
4954 Self::DISPLAY_EVENT_INFO_EXT => Some("DISPLAY_EVENT_INFO_EXT"),
4955 Self::SWAPCHAIN_COUNTER_CREATE_INFO_EXT => Some("SWAPCHAIN_COUNTER_CREATE_INFO_EXT"),
4956 Self::PRESENT_TIMES_INFO_GOOGLE => Some("PRESENT_TIMES_INFO_GOOGLE"),
4957 Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX => {
4958 Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX")
4959 }
4960 Self::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV => {
4961 Some("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV")
4962 }
4963 Self::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT => {
4964 Some("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT")
4965 }
4966 Self::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT => {
4967 Some("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT")
4968 }
4969 Self::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT => {
4970 Some("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT")
4971 }
4972 Self::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT => {
4973 Some("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT")
4974 }
4975 Self::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT => {
4976 Some("PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT")
4977 }
4978 Self::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT => {
4979 Some("PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT")
4980 }
4981 Self::HDR_METADATA_EXT => Some("HDR_METADATA_EXT"),
4982 Self::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR => {
4983 Some("SHARED_PRESENT_SURFACE_CAPABILITIES_KHR")
4984 }
4985 Self::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"),
4986 Self::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"),
4987 Self::FENCE_GET_WIN32_HANDLE_INFO_KHR => Some("FENCE_GET_WIN32_HANDLE_INFO_KHR"),
4988 Self::IMPORT_FENCE_FD_INFO_KHR => Some("IMPORT_FENCE_FD_INFO_KHR"),
4989 Self::FENCE_GET_FD_INFO_KHR => Some("FENCE_GET_FD_INFO_KHR"),
4990 Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR => {
4991 Some("PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR")
4992 }
4993 Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR => {
4994 Some("PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR")
4995 }
4996 Self::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR => {
4997 Some("QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR")
4998 }
4999 Self::PERFORMANCE_QUERY_SUBMIT_INFO_KHR => Some("PERFORMANCE_QUERY_SUBMIT_INFO_KHR"),
5000 Self::ACQUIRE_PROFILING_LOCK_INFO_KHR => Some("ACQUIRE_PROFILING_LOCK_INFO_KHR"),
5001 Self::PERFORMANCE_COUNTER_KHR => Some("PERFORMANCE_COUNTER_KHR"),
5002 Self::PERFORMANCE_COUNTER_DESCRIPTION_KHR => {
5003 Some("PERFORMANCE_COUNTER_DESCRIPTION_KHR")
5004 }
5005 Self::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR => Some("PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"),
5006 Self::SURFACE_CAPABILITIES_2_KHR => Some("SURFACE_CAPABILITIES_2_KHR"),
5007 Self::SURFACE_FORMAT_2_KHR => Some("SURFACE_FORMAT_2_KHR"),
5008 Self::DISPLAY_PROPERTIES_2_KHR => Some("DISPLAY_PROPERTIES_2_KHR"),
5009 Self::DISPLAY_PLANE_PROPERTIES_2_KHR => Some("DISPLAY_PLANE_PROPERTIES_2_KHR"),
5010 Self::DISPLAY_MODE_PROPERTIES_2_KHR => Some("DISPLAY_MODE_PROPERTIES_2_KHR"),
5011 Self::DISPLAY_PLANE_INFO_2_KHR => Some("DISPLAY_PLANE_INFO_2_KHR"),
5012 Self::DISPLAY_PLANE_CAPABILITIES_2_KHR => Some("DISPLAY_PLANE_CAPABILITIES_2_KHR"),
5013 Self::IOS_SURFACE_CREATE_INFO_MVK => Some("IOS_SURFACE_CREATE_INFO_MVK"),
5014 Self::MACOS_SURFACE_CREATE_INFO_MVK => Some("MACOS_SURFACE_CREATE_INFO_MVK"),
5015 Self::DEBUG_UTILS_OBJECT_NAME_INFO_EXT => Some("DEBUG_UTILS_OBJECT_NAME_INFO_EXT"),
5016 Self::DEBUG_UTILS_OBJECT_TAG_INFO_EXT => Some("DEBUG_UTILS_OBJECT_TAG_INFO_EXT"),
5017 Self::DEBUG_UTILS_LABEL_EXT => Some("DEBUG_UTILS_LABEL_EXT"),
5018 Self::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT => {
5019 Some("DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT")
5020 }
5021 Self::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT => {
5022 Some("DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT")
5023 }
5024 Self::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID => {
5025 Some("ANDROID_HARDWARE_BUFFER_USAGE_ANDROID")
5026 }
5027 Self::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID => {
5028 Some("ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID")
5029 }
5030 Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID => {
5031 Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID")
5032 }
5033 Self::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => {
5034 Some("IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID")
5035 }
5036 Self::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => {
5037 Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID")
5038 }
5039 Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"),
5040 Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID => {
5041 Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID")
5042 }
5043 Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"),
5044 Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => {
5045 Some("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT")
5046 }
5047 Self::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT => {
5048 Some("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT")
5049 }
5050 Self::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT => {
5051 Some("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT")
5052 }
5053 Self::MULTISAMPLE_PROPERTIES_EXT => Some("MULTISAMPLE_PROPERTIES_EXT"),
5054 Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT => {
5055 Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT")
5056 }
5057 Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT => {
5058 Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT")
5059 }
5060 Self::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT => {
5061 Some("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT")
5062 }
5063 Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => {
5064 Some("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV")
5065 }
5066 Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR => {
5067 Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR")
5068 }
5069 Self::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR => {
5070 Some("ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR")
5071 }
5072 Self::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR => {
5073 Some("ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR")
5074 }
5075 Self::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR => {
5076 Some("ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR")
5077 }
5078 Self::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR => {
5079 Some("ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR")
5080 }
5081 Self::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR => {
5082 Some("ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR")
5083 }
5084 Self::ACCELERATION_STRUCTURE_GEOMETRY_KHR => {
5085 Some("ACCELERATION_STRUCTURE_GEOMETRY_KHR")
5086 }
5087 Self::ACCELERATION_STRUCTURE_VERSION_INFO_KHR => {
5088 Some("ACCELERATION_STRUCTURE_VERSION_INFO_KHR")
5089 }
5090 Self::COPY_ACCELERATION_STRUCTURE_INFO_KHR => {
5091 Some("COPY_ACCELERATION_STRUCTURE_INFO_KHR")
5092 }
5093 Self::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR => {
5094 Some("COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR")
5095 }
5096 Self::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR => {
5097 Some("COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR")
5098 }
5099 Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR => {
5100 Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR")
5101 }
5102 Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR => {
5103 Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR")
5104 }
5105 Self::ACCELERATION_STRUCTURE_CREATE_INFO_KHR => {
5106 Some("ACCELERATION_STRUCTURE_CREATE_INFO_KHR")
5107 }
5108 Self::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR => {
5109 Some("ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR")
5110 }
5111 Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR => {
5112 Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR")
5113 }
5114 Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR => {
5115 Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR")
5116 }
5117 Self::RAY_TRACING_PIPELINE_CREATE_INFO_KHR => {
5118 Some("RAY_TRACING_PIPELINE_CREATE_INFO_KHR")
5119 }
5120 Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR => {
5121 Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR")
5122 }
5123 Self::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR => {
5124 Some("RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR")
5125 }
5126 Self::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR => {
5127 Some("PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR")
5128 }
5129 Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => {
5130 Some("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV")
5131 }
5132 Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV => {
5133 Some("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV")
5134 }
5135 Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV => {
5136 Some("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV")
5137 }
5138 Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT => {
5139 Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT")
5140 }
5141 Self::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT => {
5142 Some("PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT")
5143 }
5144 Self::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT => {
5145 Some("IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT")
5146 }
5147 Self::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT => {
5148 Some("IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT")
5149 }
5150 Self::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT => {
5151 Some("IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT")
5152 }
5153 Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT => {
5154 Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT")
5155 }
5156 Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"),
5157 Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => {
5158 Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT")
5159 }
5160 Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR => {
5161 Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR")
5162 }
5163 Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR => {
5164 Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR")
5165 }
5166 Self::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV => {
5167 Some("PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV")
5168 }
5169 Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV => {
5170 Some("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV")
5171 }
5172 Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV => {
5173 Some("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV")
5174 }
5175 Self::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV => {
5176 Some("PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV")
5177 }
5178 Self::RAY_TRACING_PIPELINE_CREATE_INFO_NV => {
5179 Some("RAY_TRACING_PIPELINE_CREATE_INFO_NV")
5180 }
5181 Self::ACCELERATION_STRUCTURE_CREATE_INFO_NV => {
5182 Some("ACCELERATION_STRUCTURE_CREATE_INFO_NV")
5183 }
5184 Self::GEOMETRY_NV => Some("GEOMETRY_NV"),
5185 Self::GEOMETRY_TRIANGLES_NV => Some("GEOMETRY_TRIANGLES_NV"),
5186 Self::GEOMETRY_AABB_NV => Some("GEOMETRY_AABB_NV"),
5187 Self::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV => {
5188 Some("BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV")
5189 }
5190 Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV => {
5191 Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV")
5192 }
5193 Self::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV => {
5194 Some("ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV")
5195 }
5196 Self::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV => {
5197 Some("PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV")
5198 }
5199 Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV => {
5200 Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV")
5201 }
5202 Self::ACCELERATION_STRUCTURE_INFO_NV => Some("ACCELERATION_STRUCTURE_INFO_NV"),
5203 Self::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV => {
5204 Some("PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV")
5205 }
5206 Self::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV => {
5207 Some("PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV")
5208 }
5209 Self::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT => {
5210 Some("PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT")
5211 }
5212 Self::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT => {
5213 Some("FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT")
5214 }
5215 Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => {
5216 Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT")
5217 }
5218 Self::MEMORY_HOST_POINTER_PROPERTIES_EXT => Some("MEMORY_HOST_POINTER_PROPERTIES_EXT"),
5219 Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT => {
5220 Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT")
5221 }
5222 Self::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR => {
5223 Some("PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR")
5224 }
5225 Self::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD => {
5226 Some("PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD")
5227 }
5228 Self::CALIBRATED_TIMESTAMP_INFO_EXT => Some("CALIBRATED_TIMESTAMP_INFO_EXT"),
5229 Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => {
5230 Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD")
5231 }
5232 Self::VIDEO_DECODE_H265_CAPABILITIES_KHR => Some("VIDEO_DECODE_H265_CAPABILITIES_KHR"),
5233 Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR => {
5234 Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR")
5235 }
5236 Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR => {
5237 Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR")
5238 }
5239 Self::VIDEO_DECODE_H265_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H265_PROFILE_INFO_KHR"),
5240 Self::VIDEO_DECODE_H265_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H265_PICTURE_INFO_KHR"),
5241 Self::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR => {
5242 Some("VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR")
5243 }
5244 Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR => {
5245 Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR")
5246 }
5247 Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR => {
5248 Some("PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR")
5249 }
5250 Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR => {
5251 Some("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR")
5252 }
5253 Self::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD => {
5254 Some("DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD")
5255 }
5256 Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT => {
5257 Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT")
5258 }
5259 Self::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT => {
5260 Some("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT")
5261 }
5262 Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT => {
5263 Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT")
5264 }
5265 Self::PRESENT_FRAME_TOKEN_GGP => Some("PRESENT_FRAME_TOKEN_GGP"),
5266 Self::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV => {
5267 Some("PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV")
5268 }
5269 Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV => {
5270 Some("PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV")
5271 }
5272 Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV => {
5273 Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV")
5274 }
5275 Self::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV => {
5276 Some("PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV")
5277 }
5278 Self::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV => {
5279 Some("PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV")
5280 }
5281 Self::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV => {
5282 Some("PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV")
5283 }
5284 Self::CHECKPOINT_DATA_NV => Some("CHECKPOINT_DATA_NV"),
5285 Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV => {
5286 Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV")
5287 }
5288 Self::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL => {
5289 Some("PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL")
5290 }
5291 Self::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL => {
5292 Some("QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL")
5293 }
5294 Self::INITIALIZE_PERFORMANCE_API_INFO_INTEL => {
5295 Some("INITIALIZE_PERFORMANCE_API_INFO_INTEL")
5296 }
5297 Self::PERFORMANCE_MARKER_INFO_INTEL => Some("PERFORMANCE_MARKER_INFO_INTEL"),
5298 Self::PERFORMANCE_STREAM_MARKER_INFO_INTEL => {
5299 Some("PERFORMANCE_STREAM_MARKER_INFO_INTEL")
5300 }
5301 Self::PERFORMANCE_OVERRIDE_INFO_INTEL => Some("PERFORMANCE_OVERRIDE_INFO_INTEL"),
5302 Self::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL => {
5303 Some("PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL")
5304 }
5305 Self::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT => {
5306 Some("PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT")
5307 }
5308 Self::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD => {
5309 Some("DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD")
5310 }
5311 Self::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD => {
5312 Some("SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD")
5313 }
5314 Self::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA => {
5315 Some("IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA")
5316 }
5317 Self::METAL_SURFACE_CREATE_INFO_EXT => Some("METAL_SURFACE_CREATE_INFO_EXT"),
5318 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT => {
5319 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT")
5320 }
5321 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT => {
5322 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT")
5323 }
5324 Self::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT => {
5325 Some("RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT")
5326 }
5327 Self::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => {
5328 Some("FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR")
5329 }
5330 Self::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR => {
5331 Some("PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR")
5332 }
5333 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR => {
5334 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR")
5335 }
5336 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR => {
5337 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR")
5338 }
5339 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR => {
5340 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR")
5341 }
5342 Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD => {
5343 Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD")
5344 }
5345 Self::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD => {
5346 Some("PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD")
5347 }
5348 Self::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT => {
5349 Some("PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT")
5350 }
5351 Self::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT => {
5352 Some("PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT")
5353 }
5354 Self::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT => {
5355 Some("PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT")
5356 }
5357 Self::MEMORY_PRIORITY_ALLOCATE_INFO_EXT => Some("MEMORY_PRIORITY_ALLOCATE_INFO_EXT"),
5358 Self::SURFACE_PROTECTED_CAPABILITIES_KHR => Some("SURFACE_PROTECTED_CAPABILITIES_KHR"),
5359 Self::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV => {
5360 Some("PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV")
5361 }
5362 Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT => {
5363 Some("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT")
5364 }
5365 Self::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT => {
5366 Some("BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT")
5367 }
5368 Self::VALIDATION_FEATURES_EXT => Some("VALIDATION_FEATURES_EXT"),
5369 Self::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR => {
5370 Some("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR")
5371 }
5372 Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV => {
5373 Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV")
5374 }
5375 Self::COOPERATIVE_MATRIX_PROPERTIES_NV => Some("COOPERATIVE_MATRIX_PROPERTIES_NV"),
5376 Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV => {
5377 Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV")
5378 }
5379 Self::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV => {
5380 Some("PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV")
5381 }
5382 Self::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV => {
5383 Some("PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV")
5384 }
5385 Self::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV => {
5386 Some("FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV")
5387 }
5388 Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT => {
5389 Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT")
5390 }
5391 Self::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT => {
5392 Some("PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT")
5393 }
5394 Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT => {
5395 Some("PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT")
5396 }
5397 Self::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT => {
5398 Some("PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT")
5399 }
5400 Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT => {
5401 Some("PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT")
5402 }
5403 Self::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT => {
5404 Some("SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT")
5405 }
5406 Self::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT => {
5407 Some("SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT")
5408 }
5409 Self::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT => {
5410 Some("SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT")
5411 }
5412 Self::HEADLESS_SURFACE_CREATE_INFO_EXT => Some("HEADLESS_SURFACE_CREATE_INFO_EXT"),
5413 Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT => {
5414 Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT")
5415 }
5416 Self::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT => {
5417 Some("PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT")
5418 }
5419 Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT => {
5420 Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT")
5421 }
5422 Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT => {
5423 Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT")
5424 }
5425 Self::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT => {
5426 Some("PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT")
5427 }
5428 Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT => {
5429 Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT")
5430 }
5431 Self::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR => {
5432 Some("PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR")
5433 }
5434 Self::PIPELINE_INFO_KHR => Some("PIPELINE_INFO_KHR"),
5435 Self::PIPELINE_EXECUTABLE_PROPERTIES_KHR => Some("PIPELINE_EXECUTABLE_PROPERTIES_KHR"),
5436 Self::PIPELINE_EXECUTABLE_INFO_KHR => Some("PIPELINE_EXECUTABLE_INFO_KHR"),
5437 Self::PIPELINE_EXECUTABLE_STATISTIC_KHR => Some("PIPELINE_EXECUTABLE_STATISTIC_KHR"),
5438 Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => {
5439 Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR")
5440 }
5441 Self::MEMORY_MAP_INFO_KHR => Some("MEMORY_MAP_INFO_KHR"),
5442 Self::MEMORY_UNMAP_INFO_KHR => Some("MEMORY_UNMAP_INFO_KHR"),
5443 Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => {
5444 Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT")
5445 }
5446 Self::SURFACE_PRESENT_MODE_EXT => Some("SURFACE_PRESENT_MODE_EXT"),
5447 Self::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT => {
5448 Some("SURFACE_PRESENT_SCALING_CAPABILITIES_EXT")
5449 }
5450 Self::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT => {
5451 Some("SURFACE_PRESENT_MODE_COMPATIBILITY_EXT")
5452 }
5453 Self::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT => {
5454 Some("PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT")
5455 }
5456 Self::SWAPCHAIN_PRESENT_FENCE_INFO_EXT => Some("SWAPCHAIN_PRESENT_FENCE_INFO_EXT"),
5457 Self::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT => {
5458 Some("SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT")
5459 }
5460 Self::SWAPCHAIN_PRESENT_MODE_INFO_EXT => Some("SWAPCHAIN_PRESENT_MODE_INFO_EXT"),
5461 Self::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT => {
5462 Some("SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT")
5463 }
5464 Self::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT => Some("RELEASE_SWAPCHAIN_IMAGES_INFO_EXT"),
5465 Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV => {
5466 Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV")
5467 }
5468 Self::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV => {
5469 Some("GRAPHICS_SHADER_GROUP_CREATE_INFO_NV")
5470 }
5471 Self::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV => {
5472 Some("GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV")
5473 }
5474 Self::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV => Some("INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"),
5475 Self::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV => {
5476 Some("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV")
5477 }
5478 Self::GENERATED_COMMANDS_INFO_NV => Some("GENERATED_COMMANDS_INFO_NV"),
5479 Self::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV => {
5480 Some("GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV")
5481 }
5482 Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV => {
5483 Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV")
5484 }
5485 Self::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV => {
5486 Some("PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV")
5487 }
5488 Self::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV => {
5489 Some("COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV")
5490 }
5491 Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT => {
5492 Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT")
5493 }
5494 Self::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM => {
5495 Some("COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM")
5496 }
5497 Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => {
5498 Some("RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM")
5499 }
5500 Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => {
5501 Some("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT")
5502 }
5503 Self::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT => {
5504 Some("DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT")
5505 }
5506 Self::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT => {
5507 Some("DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT")
5508 }
5509 Self::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT => {
5510 Some("PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT")
5511 }
5512 Self::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT => {
5513 Some("PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT")
5514 }
5515 Self::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT => {
5516 Some("SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT")
5517 }
5518 Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT => {
5519 Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT")
5520 }
5521 Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT => {
5522 Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT")
5523 }
5524 Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"),
5525 Self::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV => {
5526 Some("PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV")
5527 }
5528 Self::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV => {
5529 Some("SURFACE_CAPABILITIES_PRESENT_BARRIER_NV")
5530 }
5531 Self::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV => {
5532 Some("SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV")
5533 }
5534 Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"),
5535 Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => {
5536 Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR")
5537 }
5538 Self::VIDEO_ENCODE_INFO_KHR => Some("VIDEO_ENCODE_INFO_KHR"),
5539 Self::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR => Some("VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"),
5540 Self::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR => {
5541 Some("VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR")
5542 }
5543 Self::VIDEO_ENCODE_CAPABILITIES_KHR => Some("VIDEO_ENCODE_CAPABILITIES_KHR"),
5544 Self::VIDEO_ENCODE_USAGE_INFO_KHR => Some("VIDEO_ENCODE_USAGE_INFO_KHR"),
5545 Self::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR => {
5546 Some("QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR")
5547 }
5548 Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => {
5549 Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV")
5550 }
5551 Self::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV => {
5552 Some("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV")
5553 }
5554 Self::RESERVED_QCOM => Some("RESERVED_QCOM"),
5555 Self::QUERY_LOW_LATENCY_SUPPORT_NV => Some("QUERY_LOW_LATENCY_SUPPORT_NV"),
5556 Self::EXPORT_METAL_OBJECT_CREATE_INFO_EXT => {
5557 Some("EXPORT_METAL_OBJECT_CREATE_INFO_EXT")
5558 }
5559 Self::EXPORT_METAL_OBJECTS_INFO_EXT => Some("EXPORT_METAL_OBJECTS_INFO_EXT"),
5560 Self::EXPORT_METAL_DEVICE_INFO_EXT => Some("EXPORT_METAL_DEVICE_INFO_EXT"),
5561 Self::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT => {
5562 Some("EXPORT_METAL_COMMAND_QUEUE_INFO_EXT")
5563 }
5564 Self::EXPORT_METAL_BUFFER_INFO_EXT => Some("EXPORT_METAL_BUFFER_INFO_EXT"),
5565 Self::IMPORT_METAL_BUFFER_INFO_EXT => Some("IMPORT_METAL_BUFFER_INFO_EXT"),
5566 Self::EXPORT_METAL_TEXTURE_INFO_EXT => Some("EXPORT_METAL_TEXTURE_INFO_EXT"),
5567 Self::IMPORT_METAL_TEXTURE_INFO_EXT => Some("IMPORT_METAL_TEXTURE_INFO_EXT"),
5568 Self::EXPORT_METAL_IO_SURFACE_INFO_EXT => Some("EXPORT_METAL_IO_SURFACE_INFO_EXT"),
5569 Self::IMPORT_METAL_IO_SURFACE_INFO_EXT => Some("IMPORT_METAL_IO_SURFACE_INFO_EXT"),
5570 Self::EXPORT_METAL_SHARED_EVENT_INFO_EXT => Some("EXPORT_METAL_SHARED_EVENT_INFO_EXT"),
5571 Self::IMPORT_METAL_SHARED_EVENT_INFO_EXT => Some("IMPORT_METAL_SHARED_EVENT_INFO_EXT"),
5572 Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV => {
5573 Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV")
5574 }
5575 Self::CHECKPOINT_DATA_2_NV => Some("CHECKPOINT_DATA_2_NV"),
5576 Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT => {
5577 Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT")
5578 }
5579 Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT => {
5580 Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT")
5581 }
5582 Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT => {
5583 Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT")
5584 }
5585 Self::DESCRIPTOR_ADDRESS_INFO_EXT => Some("DESCRIPTOR_ADDRESS_INFO_EXT"),
5586 Self::DESCRIPTOR_GET_INFO_EXT => Some("DESCRIPTOR_GET_INFO_EXT"),
5587 Self::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
5588 Some("BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
5589 }
5590 Self::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
5591 Some("IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
5592 }
5593 Self::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
5594 Some("IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
5595 }
5596 Self::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
5597 Some("SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
5598 }
5599 Self::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT => {
5600 Some("OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT")
5601 }
5602 Self::DESCRIPTOR_BUFFER_BINDING_INFO_EXT => Some("DESCRIPTOR_BUFFER_BINDING_INFO_EXT"),
5603 Self::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT => {
5604 Some("DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT")
5605 }
5606 Self::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
5607 Some("ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
5608 }
5609 Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT => {
5610 Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT")
5611 }
5612 Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT => {
5613 Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT")
5614 }
5615 Self::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT => {
5616 Some("GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT")
5617 }
5618 Self::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD => {
5619 Some("PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD")
5620 }
5621 Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR => {
5622 Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR")
5623 }
5624 Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR => {
5625 Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR")
5626 }
5627 Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR => {
5628 Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR")
5629 }
5630 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV => {
5631 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV")
5632 }
5633 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV => {
5634 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV")
5635 }
5636 Self::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV => {
5637 Some("PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV")
5638 }
5639 Self::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV => {
5640 Some("ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV")
5641 }
5642 Self::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV => {
5643 Some("PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV")
5644 }
5645 Self::ACCELERATION_STRUCTURE_MOTION_INFO_NV => {
5646 Some("ACCELERATION_STRUCTURE_MOTION_INFO_NV")
5647 }
5648 Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT => {
5649 Some("PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT")
5650 }
5651 Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT => {
5652 Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT")
5653 }
5654 Self::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT => {
5655 Some("PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT")
5656 }
5657 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT => {
5658 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT")
5659 }
5660 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT => {
5661 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT")
5662 }
5663 Self::COPY_COMMAND_TRANSFORM_INFO_QCOM => Some("COPY_COMMAND_TRANSFORM_INFO_QCOM"),
5664 Self::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR => {
5665 Some("PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR")
5666 }
5667 Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT => {
5668 Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT")
5669 }
5670 Self::IMAGE_COMPRESSION_CONTROL_EXT => Some("IMAGE_COMPRESSION_CONTROL_EXT"),
5671 Self::SUBRESOURCE_LAYOUT_2_EXT => Some("SUBRESOURCE_LAYOUT_2_EXT"),
5672 Self::IMAGE_SUBRESOURCE_2_EXT => Some("IMAGE_SUBRESOURCE_2_EXT"),
5673 Self::IMAGE_COMPRESSION_PROPERTIES_EXT => Some("IMAGE_COMPRESSION_PROPERTIES_EXT"),
5674 Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT => {
5675 Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT")
5676 }
5677 Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => {
5678 Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT")
5679 }
5680 Self::PHYSICAL_DEVICE_FAULT_FEATURES_EXT => Some("PHYSICAL_DEVICE_FAULT_FEATURES_EXT"),
5681 Self::DEVICE_FAULT_COUNTS_EXT => Some("DEVICE_FAULT_COUNTS_EXT"),
5682 Self::DEVICE_FAULT_INFO_EXT => Some("DEVICE_FAULT_INFO_EXT"),
5683 Self::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT => {
5684 Some("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT")
5685 }
5686 Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"),
5687 Self::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT => {
5688 Some("PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT")
5689 }
5690 Self::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT => {
5691 Some("VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT")
5692 }
5693 Self::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT => {
5694 Some("VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT")
5695 }
5696 Self::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT => Some("PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"),
5697 Self::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT => {
5698 Some("PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT")
5699 }
5700 Self::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT => {
5701 Some("DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT")
5702 }
5703 Self::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT => {
5704 Some("PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT")
5705 }
5706 Self::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT => {
5707 Some("PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT")
5708 }
5709 Self::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT => {
5710 Some("PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT")
5711 }
5712 Self::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA => {
5713 Some("IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA")
5714 }
5715 Self::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA => {
5716 Some("MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA")
5717 }
5718 Self::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA => {
5719 Some("MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA")
5720 }
5721 Self::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA => {
5722 Some("IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA")
5723 }
5724 Self::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA => {
5725 Some("SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA")
5726 }
5727 Self::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA => {
5728 Some("BUFFER_COLLECTION_CREATE_INFO_FUCHSIA")
5729 }
5730 Self::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA => {
5731 Some("IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA")
5732 }
5733 Self::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA => {
5734 Some("BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA")
5735 }
5736 Self::BUFFER_COLLECTION_PROPERTIES_FUCHSIA => {
5737 Some("BUFFER_COLLECTION_PROPERTIES_FUCHSIA")
5738 }
5739 Self::BUFFER_CONSTRAINTS_INFO_FUCHSIA => Some("BUFFER_CONSTRAINTS_INFO_FUCHSIA"),
5740 Self::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA => {
5741 Some("BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA")
5742 }
5743 Self::IMAGE_CONSTRAINTS_INFO_FUCHSIA => Some("IMAGE_CONSTRAINTS_INFO_FUCHSIA"),
5744 Self::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA => {
5745 Some("IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA")
5746 }
5747 Self::SYSMEM_COLOR_SPACE_FUCHSIA => Some("SYSMEM_COLOR_SPACE_FUCHSIA"),
5748 Self::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA => {
5749 Some("BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA")
5750 }
5751 Self::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI => {
5752 Some("SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI")
5753 }
5754 Self::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI => {
5755 Some("PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI")
5756 }
5757 Self::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI => {
5758 Some("PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI")
5759 }
5760 Self::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI => {
5761 Some("PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI")
5762 }
5763 Self::MEMORY_GET_REMOTE_ADDRESS_INFO_NV => Some("MEMORY_GET_REMOTE_ADDRESS_INFO_NV"),
5764 Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => {
5765 Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV")
5766 }
5767 Self::PIPELINE_PROPERTIES_IDENTIFIER_EXT => Some("PIPELINE_PROPERTIES_IDENTIFIER_EXT"),
5768 Self::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT => {
5769 Some("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT")
5770 }
5771 Self::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT => {
5772 Some("PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT")
5773 }
5774 Self::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT => {
5775 Some("SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT")
5776 }
5777 Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT => {
5778 Some("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT")
5779 }
5780 Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT => {
5781 Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT")
5782 }
5783 Self::SCREEN_SURFACE_CREATE_INFO_QNX => Some("SCREEN_SURFACE_CREATE_INFO_QNX"),
5784 Self::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT => {
5785 Some("PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT")
5786 }
5787 Self::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT => {
5788 Some("PIPELINE_COLOR_WRITE_CREATE_INFO_EXT")
5789 }
5790 Self::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT => {
5791 Some("PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT")
5792 }
5793 Self::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR => {
5794 Some("PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR")
5795 }
5796 Self::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT => {
5797 Some("PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT")
5798 }
5799 Self::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT => Some("IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"),
5800 Self::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT => {
5801 Some("PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT")
5802 }
5803 Self::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT => {
5804 Some("PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT")
5805 }
5806 Self::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT => {
5807 Some("PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT")
5808 }
5809 Self::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT => {
5810 Some("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT")
5811 }
5812 Self::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT => {
5813 Some("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT")
5814 }
5815 Self::MICROMAP_BUILD_INFO_EXT => Some("MICROMAP_BUILD_INFO_EXT"),
5816 Self::MICROMAP_VERSION_INFO_EXT => Some("MICROMAP_VERSION_INFO_EXT"),
5817 Self::COPY_MICROMAP_INFO_EXT => Some("COPY_MICROMAP_INFO_EXT"),
5818 Self::COPY_MICROMAP_TO_MEMORY_INFO_EXT => Some("COPY_MICROMAP_TO_MEMORY_INFO_EXT"),
5819 Self::COPY_MEMORY_TO_MICROMAP_INFO_EXT => Some("COPY_MEMORY_TO_MICROMAP_INFO_EXT"),
5820 Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT => {
5821 Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT")
5822 }
5823 Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT => {
5824 Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT")
5825 }
5826 Self::MICROMAP_CREATE_INFO_EXT => Some("MICROMAP_CREATE_INFO_EXT"),
5827 Self::MICROMAP_BUILD_SIZES_INFO_EXT => Some("MICROMAP_BUILD_SIZES_INFO_EXT"),
5828 Self::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT => {
5829 Some("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT")
5830 }
5831 Self::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV => {
5832 Some("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV")
5833 }
5834 Self::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV => {
5835 Some("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV")
5836 }
5837 Self::ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV => {
5838 Some("ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV")
5839 }
5840 Self::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI => {
5841 Some("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI")
5842 }
5843 Self::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI => {
5844 Some("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI")
5845 }
5846 Self::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT => {
5847 Some("PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT")
5848 }
5849 Self::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT => {
5850 Some("SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT")
5851 }
5852 Self::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT => {
5853 Some("PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT")
5854 }
5855 Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM => {
5856 Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM")
5857 }
5858 Self::PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT => {
5859 Some("PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT")
5860 }
5861 Self::IMAGE_VIEW_SLICED_CREATE_INFO_EXT => Some("IMAGE_VIEW_SLICED_CREATE_INFO_EXT"),
5862 Self::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE => {
5863 Some("PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE")
5864 }
5865 Self::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE => {
5866 Some("DESCRIPTOR_SET_BINDING_REFERENCE_VALVE")
5867 }
5868 Self::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE => {
5869 Some("DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE")
5870 }
5871 Self::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT => {
5872 Some("PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT")
5873 }
5874 Self::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT => {
5875 Some("PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT")
5876 }
5877 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM => {
5878 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM")
5879 }
5880 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM => {
5881 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM")
5882 }
5883 Self::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM => {
5884 Some("SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM")
5885 }
5886 Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV => {
5887 Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV")
5888 }
5889 Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV => {
5890 Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV")
5891 }
5892 Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV => {
5893 Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV")
5894 }
5895 Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV => {
5896 Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV")
5897 }
5898 Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => {
5899 Some("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV")
5900 }
5901 Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT => {
5902 Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT")
5903 }
5904 Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM => {
5905 Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM")
5906 }
5907 Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM => {
5908 Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM")
5909 }
5910 Self::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM => {
5911 Some("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM")
5912 }
5913 Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT => {
5914 Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT")
5915 }
5916 Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT => {
5917 Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT")
5918 }
5919 Self::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT => {
5920 Some("PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT")
5921 }
5922 Self::RENDER_PASS_CREATION_CONTROL_EXT => Some("RENDER_PASS_CREATION_CONTROL_EXT"),
5923 Self::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT => {
5924 Some("RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT")
5925 }
5926 Self::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT => {
5927 Some("RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT")
5928 }
5929 Self::DIRECT_DRIVER_LOADING_INFO_LUNARG => Some("DIRECT_DRIVER_LOADING_INFO_LUNARG"),
5930 Self::DIRECT_DRIVER_LOADING_LIST_LUNARG => Some("DIRECT_DRIVER_LOADING_LIST_LUNARG"),
5931 Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT => {
5932 Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT")
5933 }
5934 Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT => {
5935 Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT")
5936 }
5937 Self::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT => {
5938 Some("PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT")
5939 }
5940 Self::SHADER_MODULE_IDENTIFIER_EXT => Some("SHADER_MODULE_IDENTIFIER_EXT"),
5941 Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT => {
5942 Some("PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT")
5943 }
5944 Self::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV => {
5945 Some("PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV")
5946 }
5947 Self::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV => {
5948 Some("PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV")
5949 }
5950 Self::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV => Some("OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV"),
5951 Self::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV => {
5952 Some("OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV")
5953 }
5954 Self::OPTICAL_FLOW_SESSION_CREATE_INFO_NV => {
5955 Some("OPTICAL_FLOW_SESSION_CREATE_INFO_NV")
5956 }
5957 Self::OPTICAL_FLOW_EXECUTE_INFO_NV => Some("OPTICAL_FLOW_EXECUTE_INFO_NV"),
5958 Self::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV => {
5959 Some("OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV")
5960 }
5961 Self::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT => {
5962 Some("PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT")
5963 }
5964 Self::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT => {
5965 Some("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT")
5966 }
5967 Self::PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR => {
5968 Some("PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR")
5969 }
5970 Self::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT => {
5971 Some("PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT")
5972 }
5973 Self::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT => {
5974 Some("PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT")
5975 }
5976 Self::SHADER_CREATE_INFO_EXT => Some("SHADER_CREATE_INFO_EXT"),
5977 Self::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM => {
5978 Some("PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM")
5979 }
5980 Self::TILE_PROPERTIES_QCOM => Some("TILE_PROPERTIES_QCOM"),
5981 Self::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC => {
5982 Some("PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC")
5983 }
5984 Self::AMIGO_PROFILING_SUBMIT_INFO_SEC => Some("AMIGO_PROFILING_SUBMIT_INFO_SEC"),
5985 Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM => {
5986 Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM")
5987 }
5988 Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV => {
5989 Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV")
5990 }
5991 Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV => {
5992 Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV")
5993 }
5994 Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT => {
5995 Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT")
5996 }
5997 Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT => {
5998 Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT")
5999 }
6000 Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM => {
6001 Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM")
6002 }
6003 Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM => {
6004 Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM")
6005 }
6006 Self::PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT => {
6007 Some("PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT")
6008 }
6009 Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT => {
6010 Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT")
6011 }
6012 Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM => {
6013 Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM")
6014 }
6015 Self::MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM => {
6016 Some("MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM")
6017 }
6018 Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT => {
6019 Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT")
6020 }
6021 Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => {
6022 Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES")
6023 }
6024 Self::BIND_BUFFER_MEMORY_INFO => Some("BIND_BUFFER_MEMORY_INFO"),
6025 Self::BIND_IMAGE_MEMORY_INFO => Some("BIND_IMAGE_MEMORY_INFO"),
6026 Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => {
6027 Some("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES")
6028 }
6029 Self::MEMORY_DEDICATED_REQUIREMENTS => Some("MEMORY_DEDICATED_REQUIREMENTS"),
6030 Self::MEMORY_DEDICATED_ALLOCATE_INFO => Some("MEMORY_DEDICATED_ALLOCATE_INFO"),
6031 Self::MEMORY_ALLOCATE_FLAGS_INFO => Some("MEMORY_ALLOCATE_FLAGS_INFO"),
6032 Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => {
6033 Some("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO")
6034 }
6035 Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => {
6036 Some("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO")
6037 }
6038 Self::DEVICE_GROUP_SUBMIT_INFO => Some("DEVICE_GROUP_SUBMIT_INFO"),
6039 Self::DEVICE_GROUP_BIND_SPARSE_INFO => Some("DEVICE_GROUP_BIND_SPARSE_INFO"),
6040 Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => {
6041 Some("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO")
6042 }
6043 Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => {
6044 Some("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO")
6045 }
6046 Self::PHYSICAL_DEVICE_GROUP_PROPERTIES => Some("PHYSICAL_DEVICE_GROUP_PROPERTIES"),
6047 Self::DEVICE_GROUP_DEVICE_CREATE_INFO => Some("DEVICE_GROUP_DEVICE_CREATE_INFO"),
6048 Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2 => Some("BUFFER_MEMORY_REQUIREMENTS_INFO_2"),
6049 Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2 => Some("IMAGE_MEMORY_REQUIREMENTS_INFO_2"),
6050 Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => {
6051 Some("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2")
6052 }
6053 Self::MEMORY_REQUIREMENTS_2 => Some("MEMORY_REQUIREMENTS_2"),
6054 Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 => Some("SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"),
6055 Self::PHYSICAL_DEVICE_FEATURES_2 => Some("PHYSICAL_DEVICE_FEATURES_2"),
6056 Self::PHYSICAL_DEVICE_PROPERTIES_2 => Some("PHYSICAL_DEVICE_PROPERTIES_2"),
6057 Self::FORMAT_PROPERTIES_2 => Some("FORMAT_PROPERTIES_2"),
6058 Self::IMAGE_FORMAT_PROPERTIES_2 => Some("IMAGE_FORMAT_PROPERTIES_2"),
6059 Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 => {
6060 Some("PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2")
6061 }
6062 Self::QUEUE_FAMILY_PROPERTIES_2 => Some("QUEUE_FAMILY_PROPERTIES_2"),
6063 Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 => {
6064 Some("PHYSICAL_DEVICE_MEMORY_PROPERTIES_2")
6065 }
6066 Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2 => Some("SPARSE_IMAGE_FORMAT_PROPERTIES_2"),
6067 Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 => {
6068 Some("PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2")
6069 }
6070 Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES => {
6071 Some("PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES")
6072 }
6073 Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO => {
6074 Some("RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO")
6075 }
6076 Self::IMAGE_VIEW_USAGE_CREATE_INFO => Some("IMAGE_VIEW_USAGE_CREATE_INFO"),
6077 Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO => {
6078 Some("PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO")
6079 }
6080 Self::RENDER_PASS_MULTIVIEW_CREATE_INFO => Some("RENDER_PASS_MULTIVIEW_CREATE_INFO"),
6081 Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES => Some("PHYSICAL_DEVICE_MULTIVIEW_FEATURES"),
6082 Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES => {
6083 Some("PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES")
6084 }
6085 Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES => {
6086 Some("PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES")
6087 }
6088 Self::PROTECTED_SUBMIT_INFO => Some("PROTECTED_SUBMIT_INFO"),
6089 Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES => {
6090 Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES")
6091 }
6092 Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES => {
6093 Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES")
6094 }
6095 Self::DEVICE_QUEUE_INFO_2 => Some("DEVICE_QUEUE_INFO_2"),
6096 Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO => {
6097 Some("SAMPLER_YCBCR_CONVERSION_CREATE_INFO")
6098 }
6099 Self::SAMPLER_YCBCR_CONVERSION_INFO => Some("SAMPLER_YCBCR_CONVERSION_INFO"),
6100 Self::BIND_IMAGE_PLANE_MEMORY_INFO => Some("BIND_IMAGE_PLANE_MEMORY_INFO"),
6101 Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO => {
6102 Some("IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO")
6103 }
6104 Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES => {
6105 Some("PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES")
6106 }
6107 Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES => {
6108 Some("SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES")
6109 }
6110 Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO => {
6111 Some("DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO")
6112 }
6113 Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO => {
6114 Some("PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO")
6115 }
6116 Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES => Some("EXTERNAL_IMAGE_FORMAT_PROPERTIES"),
6117 Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO => {
6118 Some("PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO")
6119 }
6120 Self::EXTERNAL_BUFFER_PROPERTIES => Some("EXTERNAL_BUFFER_PROPERTIES"),
6121 Self::PHYSICAL_DEVICE_ID_PROPERTIES => Some("PHYSICAL_DEVICE_ID_PROPERTIES"),
6122 Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO => Some("EXTERNAL_MEMORY_BUFFER_CREATE_INFO"),
6123 Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO => Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO"),
6124 Self::EXPORT_MEMORY_ALLOCATE_INFO => Some("EXPORT_MEMORY_ALLOCATE_INFO"),
6125 Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO => {
6126 Some("PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO")
6127 }
6128 Self::EXTERNAL_FENCE_PROPERTIES => Some("EXTERNAL_FENCE_PROPERTIES"),
6129 Self::EXPORT_FENCE_CREATE_INFO => Some("EXPORT_FENCE_CREATE_INFO"),
6130 Self::EXPORT_SEMAPHORE_CREATE_INFO => Some("EXPORT_SEMAPHORE_CREATE_INFO"),
6131 Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO => {
6132 Some("PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO")
6133 }
6134 Self::EXTERNAL_SEMAPHORE_PROPERTIES => Some("EXTERNAL_SEMAPHORE_PROPERTIES"),
6135 Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES => {
6136 Some("PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES")
6137 }
6138 Self::DESCRIPTOR_SET_LAYOUT_SUPPORT => Some("DESCRIPTOR_SET_LAYOUT_SUPPORT"),
6139 Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES => {
6140 Some("PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES")
6141 }
6142 Self::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES => {
6143 Some("PHYSICAL_DEVICE_VULKAN_1_1_FEATURES")
6144 }
6145 Self::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES => {
6146 Some("PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES")
6147 }
6148 Self::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES => {
6149 Some("PHYSICAL_DEVICE_VULKAN_1_2_FEATURES")
6150 }
6151 Self::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES => {
6152 Some("PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES")
6153 }
6154 Self::IMAGE_FORMAT_LIST_CREATE_INFO => Some("IMAGE_FORMAT_LIST_CREATE_INFO"),
6155 Self::ATTACHMENT_DESCRIPTION_2 => Some("ATTACHMENT_DESCRIPTION_2"),
6156 Self::ATTACHMENT_REFERENCE_2 => Some("ATTACHMENT_REFERENCE_2"),
6157 Self::SUBPASS_DESCRIPTION_2 => Some("SUBPASS_DESCRIPTION_2"),
6158 Self::SUBPASS_DEPENDENCY_2 => Some("SUBPASS_DEPENDENCY_2"),
6159 Self::RENDER_PASS_CREATE_INFO_2 => Some("RENDER_PASS_CREATE_INFO_2"),
6160 Self::SUBPASS_BEGIN_INFO => Some("SUBPASS_BEGIN_INFO"),
6161 Self::SUBPASS_END_INFO => Some("SUBPASS_END_INFO"),
6162 Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES => {
6163 Some("PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES")
6164 }
6165 Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES => Some("PHYSICAL_DEVICE_DRIVER_PROPERTIES"),
6166 Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES => {
6167 Some("PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES")
6168 }
6169 Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES => {
6170 Some("PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES")
6171 }
6172 Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES => {
6173 Some("PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES")
6174 }
6175 Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO => {
6176 Some("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO")
6177 }
6178 Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES => {
6179 Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES")
6180 }
6181 Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES => {
6182 Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES")
6183 }
6184 Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO => {
6185 Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO")
6186 }
6187 Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT => {
6188 Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT")
6189 }
6190 Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES => {
6191 Some("PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES")
6192 }
6193 Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE => {
6194 Some("SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE")
6195 }
6196 Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES => {
6197 Some("PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES")
6198 }
6199 Self::IMAGE_STENCIL_USAGE_CREATE_INFO => Some("IMAGE_STENCIL_USAGE_CREATE_INFO"),
6200 Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES => {
6201 Some("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES")
6202 }
6203 Self::SAMPLER_REDUCTION_MODE_CREATE_INFO => Some("SAMPLER_REDUCTION_MODE_CREATE_INFO"),
6204 Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES => {
6205 Some("PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES")
6206 }
6207 Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES => {
6208 Some("PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES")
6209 }
6210 Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO => {
6211 Some("FRAMEBUFFER_ATTACHMENTS_CREATE_INFO")
6212 }
6213 Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO => Some("FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"),
6214 Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO => Some("RENDER_PASS_ATTACHMENT_BEGIN_INFO"),
6215 Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES => {
6216 Some("PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES")
6217 }
6218 Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES => {
6219 Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES")
6220 }
6221 Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES => {
6222 Some("PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES")
6223 }
6224 Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT => {
6225 Some("ATTACHMENT_REFERENCE_STENCIL_LAYOUT")
6226 }
6227 Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT => {
6228 Some("ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT")
6229 }
6230 Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES => {
6231 Some("PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES")
6232 }
6233 Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES => {
6234 Some("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES")
6235 }
6236 Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES => {
6237 Some("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES")
6238 }
6239 Self::SEMAPHORE_TYPE_CREATE_INFO => Some("SEMAPHORE_TYPE_CREATE_INFO"),
6240 Self::TIMELINE_SEMAPHORE_SUBMIT_INFO => Some("TIMELINE_SEMAPHORE_SUBMIT_INFO"),
6241 Self::SEMAPHORE_WAIT_INFO => Some("SEMAPHORE_WAIT_INFO"),
6242 Self::SEMAPHORE_SIGNAL_INFO => Some("SEMAPHORE_SIGNAL_INFO"),
6243 Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES => {
6244 Some("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES")
6245 }
6246 Self::BUFFER_DEVICE_ADDRESS_INFO => Some("BUFFER_DEVICE_ADDRESS_INFO"),
6247 Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO => {
6248 Some("BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO")
6249 }
6250 Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO => {
6251 Some("MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO")
6252 }
6253 Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO => {
6254 Some("DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO")
6255 }
6256 Self::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES => {
6257 Some("PHYSICAL_DEVICE_VULKAN_1_3_FEATURES")
6258 }
6259 Self::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES => {
6260 Some("PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES")
6261 }
6262 Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO => {
6263 Some("PIPELINE_CREATION_FEEDBACK_CREATE_INFO")
6264 }
6265 Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES => {
6266 Some("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES")
6267 }
6268 Self::PHYSICAL_DEVICE_TOOL_PROPERTIES => Some("PHYSICAL_DEVICE_TOOL_PROPERTIES"),
6269 Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES => {
6270 Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES")
6271 }
6272 Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES => {
6273 Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES")
6274 }
6275 Self::DEVICE_PRIVATE_DATA_CREATE_INFO => Some("DEVICE_PRIVATE_DATA_CREATE_INFO"),
6276 Self::PRIVATE_DATA_SLOT_CREATE_INFO => Some("PRIVATE_DATA_SLOT_CREATE_INFO"),
6277 Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES => {
6278 Some("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES")
6279 }
6280 Self::MEMORY_BARRIER_2 => Some("MEMORY_BARRIER_2"),
6281 Self::BUFFER_MEMORY_BARRIER_2 => Some("BUFFER_MEMORY_BARRIER_2"),
6282 Self::IMAGE_MEMORY_BARRIER_2 => Some("IMAGE_MEMORY_BARRIER_2"),
6283 Self::DEPENDENCY_INFO => Some("DEPENDENCY_INFO"),
6284 Self::SUBMIT_INFO_2 => Some("SUBMIT_INFO_2"),
6285 Self::SEMAPHORE_SUBMIT_INFO => Some("SEMAPHORE_SUBMIT_INFO"),
6286 Self::COMMAND_BUFFER_SUBMIT_INFO => Some("COMMAND_BUFFER_SUBMIT_INFO"),
6287 Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES => {
6288 Some("PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES")
6289 }
6290 Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES => {
6291 Some("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES")
6292 }
6293 Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES => {
6294 Some("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES")
6295 }
6296 Self::COPY_BUFFER_INFO_2 => Some("COPY_BUFFER_INFO_2"),
6297 Self::COPY_IMAGE_INFO_2 => Some("COPY_IMAGE_INFO_2"),
6298 Self::COPY_BUFFER_TO_IMAGE_INFO_2 => Some("COPY_BUFFER_TO_IMAGE_INFO_2"),
6299 Self::COPY_IMAGE_TO_BUFFER_INFO_2 => Some("COPY_IMAGE_TO_BUFFER_INFO_2"),
6300 Self::BLIT_IMAGE_INFO_2 => Some("BLIT_IMAGE_INFO_2"),
6301 Self::RESOLVE_IMAGE_INFO_2 => Some("RESOLVE_IMAGE_INFO_2"),
6302 Self::BUFFER_COPY_2 => Some("BUFFER_COPY_2"),
6303 Self::IMAGE_COPY_2 => Some("IMAGE_COPY_2"),
6304 Self::IMAGE_BLIT_2 => Some("IMAGE_BLIT_2"),
6305 Self::BUFFER_IMAGE_COPY_2 => Some("BUFFER_IMAGE_COPY_2"),
6306 Self::IMAGE_RESOLVE_2 => Some("IMAGE_RESOLVE_2"),
6307 Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES => {
6308 Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES")
6309 }
6310 Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO => {
6311 Some("PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO")
6312 }
6313 Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES => {
6314 Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES")
6315 }
6316 Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES => {
6317 Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES")
6318 }
6319 Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES => {
6320 Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES")
6321 }
6322 Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK => {
6323 Some("WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK")
6324 }
6325 Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO => {
6326 Some("DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO")
6327 }
6328 Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES => {
6329 Some("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES")
6330 }
6331 Self::RENDERING_INFO => Some("RENDERING_INFO"),
6332 Self::RENDERING_ATTACHMENT_INFO => Some("RENDERING_ATTACHMENT_INFO"),
6333 Self::PIPELINE_RENDERING_CREATE_INFO => Some("PIPELINE_RENDERING_CREATE_INFO"),
6334 Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES => {
6335 Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES")
6336 }
6337 Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO => {
6338 Some("COMMAND_BUFFER_INHERITANCE_RENDERING_INFO")
6339 }
6340 Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES => {
6341 Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES")
6342 }
6343 Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES => {
6344 Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES")
6345 }
6346 Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES => {
6347 Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES")
6348 }
6349 Self::FORMAT_PROPERTIES_3 => Some("FORMAT_PROPERTIES_3"),
6350 Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES => {
6351 Some("PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES")
6352 }
6353 Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES => {
6354 Some("PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES")
6355 }
6356 Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS => Some("DEVICE_BUFFER_MEMORY_REQUIREMENTS"),
6357 Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS => Some("DEVICE_IMAGE_MEMORY_REQUIREMENTS"),
6358 _ => None,
6359 };
6360 if let Some(x) = name {
6361 f.write_str(x)
6362 } else {
6363 self.0.fmt(f)
6364 }
6365 }
6366}
6367impl fmt::Debug for SubgroupFeatureFlags {
6368 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6369 const KNOWN: &[(Flags, &str)] = &[
6370 (SubgroupFeatureFlags::BASIC.0, "BASIC"),
6371 (SubgroupFeatureFlags::VOTE.0, "VOTE"),
6372 (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"),
6373 (SubgroupFeatureFlags::BALLOT.0, "BALLOT"),
6374 (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"),
6375 (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"),
6376 (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"),
6377 (SubgroupFeatureFlags::QUAD.0, "QUAD"),
6378 (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"),
6379 ];
6380 debug_flags(f, KNOWN, self.0)
6381 }
6382}
6383impl fmt::Debug for SubmitFlags {
6384 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6385 const KNOWN: &[(Flags, &str)] = &[(SubmitFlags::PROTECTED.0, "PROTECTED")];
6386 debug_flags(f, KNOWN, self.0)
6387 }
6388}
6389impl fmt::Debug for SubpassContents {
6390 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6391 let name = match *self {
6392 Self::INLINE => Some("INLINE"),
6393 Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"),
6394 _ => None,
6395 };
6396 if let Some(x) = name {
6397 f.write_str(x)
6398 } else {
6399 self.0.fmt(f)
6400 }
6401 }
6402}
6403impl fmt::Debug for SubpassDescriptionFlags {
6404 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6405 const KNOWN: &[(Flags, &str)] = &[
6406 (
6407 SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0,
6408 "PER_VIEW_ATTRIBUTES_NVX",
6409 ),
6410 (
6411 SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0,
6412 "PER_VIEW_POSITION_X_ONLY_NVX",
6413 ),
6414 (
6415 SubpassDescriptionFlags::FRAGMENT_REGION_QCOM.0,
6416 "FRAGMENT_REGION_QCOM",
6417 ),
6418 (
6419 SubpassDescriptionFlags::SHADER_RESOLVE_QCOM.0,
6420 "SHADER_RESOLVE_QCOM",
6421 ),
6422 (
6423 SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT.0,
6424 "RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT",
6425 ),
6426 (
6427 SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT.0,
6428 "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT",
6429 ),
6430 (
6431 SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT.0,
6432 "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT",
6433 ),
6434 (
6435 SubpassDescriptionFlags::ENABLE_LEGACY_DITHERING_EXT.0,
6436 "ENABLE_LEGACY_DITHERING_EXT",
6437 ),
6438 ];
6439 debug_flags(f, KNOWN, self.0)
6440 }
6441}
6442impl fmt::Debug for SubpassMergeStatusEXT {
6443 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6444 let name = match *self {
6445 Self::MERGED => Some("MERGED"),
6446 Self::DISALLOWED => Some("DISALLOWED"),
6447 Self::NOT_MERGED_SIDE_EFFECTS => Some("NOT_MERGED_SIDE_EFFECTS"),
6448 Self::NOT_MERGED_SAMPLES_MISMATCH => Some("NOT_MERGED_SAMPLES_MISMATCH"),
6449 Self::NOT_MERGED_VIEWS_MISMATCH => Some("NOT_MERGED_VIEWS_MISMATCH"),
6450 Self::NOT_MERGED_ALIASING => Some("NOT_MERGED_ALIASING"),
6451 Self::NOT_MERGED_DEPENDENCIES => Some("NOT_MERGED_DEPENDENCIES"),
6452 Self::NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT => {
6453 Some("NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT")
6454 }
6455 Self::NOT_MERGED_TOO_MANY_ATTACHMENTS => Some("NOT_MERGED_TOO_MANY_ATTACHMENTS"),
6456 Self::NOT_MERGED_INSUFFICIENT_STORAGE => Some("NOT_MERGED_INSUFFICIENT_STORAGE"),
6457 Self::NOT_MERGED_DEPTH_STENCIL_COUNT => Some("NOT_MERGED_DEPTH_STENCIL_COUNT"),
6458 Self::NOT_MERGED_RESOLVE_ATTACHMENT_REUSE => {
6459 Some("NOT_MERGED_RESOLVE_ATTACHMENT_REUSE")
6460 }
6461 Self::NOT_MERGED_SINGLE_SUBPASS => Some("NOT_MERGED_SINGLE_SUBPASS"),
6462 Self::NOT_MERGED_UNSPECIFIED => Some("NOT_MERGED_UNSPECIFIED"),
6463 _ => None,
6464 };
6465 if let Some(x) = name {
6466 f.write_str(x)
6467 } else {
6468 self.0.fmt(f)
6469 }
6470 }
6471}
6472impl fmt::Debug for SurfaceCounterFlagsEXT {
6473 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6474 const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")];
6475 debug_flags(f, KNOWN, self.0)
6476 }
6477}
6478impl fmt::Debug for SurfaceTransformFlagsKHR {
6479 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6480 const KNOWN: &[(Flags, &str)] = &[
6481 (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"),
6482 (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"),
6483 (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"),
6484 (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"),
6485 (
6486 SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0,
6487 "HORIZONTAL_MIRROR",
6488 ),
6489 (
6490 SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0,
6491 "HORIZONTAL_MIRROR_ROTATE_90",
6492 ),
6493 (
6494 SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0,
6495 "HORIZONTAL_MIRROR_ROTATE_180",
6496 ),
6497 (
6498 SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0,
6499 "HORIZONTAL_MIRROR_ROTATE_270",
6500 ),
6501 (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"),
6502 ];
6503 debug_flags(f, KNOWN, self.0)
6504 }
6505}
6506impl fmt::Debug for SwapchainCreateFlagsKHR {
6507 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6508 const KNOWN: &[(Flags, &str)] = &[
6509 (
6510 SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0,
6511 "SPLIT_INSTANCE_BIND_REGIONS",
6512 ),
6513 (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"),
6514 (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"),
6515 (
6516 SwapchainCreateFlagsKHR::DEFERRED_MEMORY_ALLOCATION_EXT.0,
6517 "DEFERRED_MEMORY_ALLOCATION_EXT",
6518 ),
6519 (SwapchainCreateFlagsKHR::RESERVED_4_EXT.0, "RESERVED_4_EXT"),
6520 ];
6521 debug_flags(f, KNOWN, self.0)
6522 }
6523}
6524impl fmt::Debug for SwapchainImageUsageFlagsANDROID {
6525 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6526 const KNOWN: &[(Flags, &str)] = &[(SwapchainImageUsageFlagsANDROID::SHARED.0, "SHARED")];
6527 debug_flags(f, KNOWN, self.0)
6528 }
6529}
6530impl fmt::Debug for SystemAllocationScope {
6531 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6532 let name = match *self {
6533 Self::COMMAND => Some("COMMAND"),
6534 Self::OBJECT => Some("OBJECT"),
6535 Self::CACHE => Some("CACHE"),
6536 Self::DEVICE => Some("DEVICE"),
6537 Self::INSTANCE => Some("INSTANCE"),
6538 _ => None,
6539 };
6540 if let Some(x) = name {
6541 f.write_str(x)
6542 } else {
6543 self.0.fmt(f)
6544 }
6545 }
6546}
6547impl fmt::Debug for TessellationDomainOrigin {
6548 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6549 let name = match *self {
6550 Self::UPPER_LEFT => Some("UPPER_LEFT"),
6551 Self::LOWER_LEFT => Some("LOWER_LEFT"),
6552 _ => None,
6553 };
6554 if let Some(x) = name {
6555 f.write_str(x)
6556 } else {
6557 self.0.fmt(f)
6558 }
6559 }
6560}
6561impl fmt::Debug for TimeDomainEXT {
6562 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6563 let name = match *self {
6564 Self::DEVICE => Some("DEVICE"),
6565 Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"),
6566 Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"),
6567 Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"),
6568 _ => None,
6569 };
6570 if let Some(x) = name {
6571 f.write_str(x)
6572 } else {
6573 self.0.fmt(f)
6574 }
6575 }
6576}
6577impl fmt::Debug for ToolPurposeFlags {
6578 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6579 const KNOWN: &[(Flags, &str)] = &[
6580 (ToolPurposeFlags::VALIDATION.0, "VALIDATION"),
6581 (ToolPurposeFlags::PROFILING.0, "PROFILING"),
6582 (ToolPurposeFlags::TRACING.0, "TRACING"),
6583 (
6584 ToolPurposeFlags::ADDITIONAL_FEATURES.0,
6585 "ADDITIONAL_FEATURES",
6586 ),
6587 (ToolPurposeFlags::MODIFYING_FEATURES.0, "MODIFYING_FEATURES"),
6588 (
6589 ToolPurposeFlags::DEBUG_REPORTING_EXT.0,
6590 "DEBUG_REPORTING_EXT",
6591 ),
6592 (ToolPurposeFlags::DEBUG_MARKERS_EXT.0, "DEBUG_MARKERS_EXT"),
6593 ];
6594 debug_flags(f, KNOWN, self.0)
6595 }
6596}
6597impl fmt::Debug for ValidationCacheCreateFlagsEXT {
6598 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6599 const KNOWN: &[(Flags, &str)] = &[];
6600 debug_flags(f, KNOWN, self.0)
6601 }
6602}
6603impl fmt::Debug for ValidationCacheHeaderVersionEXT {
6604 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6605 let name = match *self {
6606 Self::ONE => Some("ONE"),
6607 _ => None,
6608 };
6609 if let Some(x) = name {
6610 f.write_str(x)
6611 } else {
6612 self.0.fmt(f)
6613 }
6614 }
6615}
6616impl fmt::Debug for ValidationCheckEXT {
6617 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6618 let name = match *self {
6619 Self::ALL => Some("ALL"),
6620 Self::SHADERS => Some("SHADERS"),
6621 _ => None,
6622 };
6623 if let Some(x) = name {
6624 f.write_str(x)
6625 } else {
6626 self.0.fmt(f)
6627 }
6628 }
6629}
6630impl fmt::Debug for ValidationFeatureDisableEXT {
6631 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6632 let name = match *self {
6633 Self::ALL => Some("ALL"),
6634 Self::SHADERS => Some("SHADERS"),
6635 Self::THREAD_SAFETY => Some("THREAD_SAFETY"),
6636 Self::API_PARAMETERS => Some("API_PARAMETERS"),
6637 Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"),
6638 Self::CORE_CHECKS => Some("CORE_CHECKS"),
6639 Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"),
6640 Self::SHADER_VALIDATION_CACHE => Some("SHADER_VALIDATION_CACHE"),
6641 _ => None,
6642 };
6643 if let Some(x) = name {
6644 f.write_str(x)
6645 } else {
6646 self.0.fmt(f)
6647 }
6648 }
6649}
6650impl fmt::Debug for ValidationFeatureEnableEXT {
6651 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6652 let name = match *self {
6653 Self::GPU_ASSISTED => Some("GPU_ASSISTED"),
6654 Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"),
6655 Self::BEST_PRACTICES => Some("BEST_PRACTICES"),
6656 Self::DEBUG_PRINTF => Some("DEBUG_PRINTF"),
6657 Self::SYNCHRONIZATION_VALIDATION => Some("SYNCHRONIZATION_VALIDATION"),
6658 _ => None,
6659 };
6660 if let Some(x) = name {
6661 f.write_str(x)
6662 } else {
6663 self.0.fmt(f)
6664 }
6665 }
6666}
6667impl fmt::Debug for VendorId {
6668 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6669 let name = match *self {
6670 Self::VIV => Some("VIV"),
6671 Self::VSI => Some("VSI"),
6672 Self::KAZAN => Some("KAZAN"),
6673 Self::CODEPLAY => Some("CODEPLAY"),
6674 Self::MESA => Some("MESA"),
6675 Self::POCL => Some("POCL"),
6676 Self::MOBILEYE => Some("MOBILEYE"),
6677 _ => None,
6678 };
6679 if let Some(x) = name {
6680 f.write_str(x)
6681 } else {
6682 self.0.fmt(f)
6683 }
6684 }
6685}
6686impl fmt::Debug for VertexInputRate {
6687 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6688 let name = match *self {
6689 Self::VERTEX => Some("VERTEX"),
6690 Self::INSTANCE => Some("INSTANCE"),
6691 _ => None,
6692 };
6693 if let Some(x) = name {
6694 f.write_str(x)
6695 } else {
6696 self.0.fmt(f)
6697 }
6698 }
6699}
6700impl fmt::Debug for ViSurfaceCreateFlagsNN {
6701 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6702 const KNOWN: &[(Flags, &str)] = &[];
6703 debug_flags(f, KNOWN, self.0)
6704 }
6705}
6706impl fmt::Debug for VideoBeginCodingFlagsKHR {
6707 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6708 const KNOWN: &[(Flags, &str)] = &[];
6709 debug_flags(f, KNOWN, self.0)
6710 }
6711}
6712impl fmt::Debug for VideoCapabilityFlagsKHR {
6713 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6714 const KNOWN: &[(Flags, &str)] = &[
6715 (
6716 VideoCapabilityFlagsKHR::PROTECTED_CONTENT.0,
6717 "PROTECTED_CONTENT",
6718 ),
6719 (
6720 VideoCapabilityFlagsKHR::SEPARATE_REFERENCE_IMAGES.0,
6721 "SEPARATE_REFERENCE_IMAGES",
6722 ),
6723 ];
6724 debug_flags(f, KNOWN, self.0)
6725 }
6726}
6727impl fmt::Debug for VideoChromaSubsamplingFlagsKHR {
6728 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6729 const KNOWN: &[(Flags, &str)] = &[
6730 (VideoChromaSubsamplingFlagsKHR::INVALID.0, "INVALID"),
6731 (VideoChromaSubsamplingFlagsKHR::MONOCHROME.0, "MONOCHROME"),
6732 (VideoChromaSubsamplingFlagsKHR::TYPE_420.0, "TYPE_420"),
6733 (VideoChromaSubsamplingFlagsKHR::TYPE_422.0, "TYPE_422"),
6734 (VideoChromaSubsamplingFlagsKHR::TYPE_444.0, "TYPE_444"),
6735 ];
6736 debug_flags(f, KNOWN, self.0)
6737 }
6738}
6739impl fmt::Debug for VideoCodecOperationFlagsKHR {
6740 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6741 const KNOWN: &[(Flags, &str)] = &[
6742 (VideoCodecOperationFlagsKHR::NONE.0, "NONE"),
6743 (
6744 VideoCodecOperationFlagsKHR::ENCODE_H264_EXT.0,
6745 "ENCODE_H264_EXT",
6746 ),
6747 (
6748 VideoCodecOperationFlagsKHR::ENCODE_H265_EXT.0,
6749 "ENCODE_H265_EXT",
6750 ),
6751 (VideoCodecOperationFlagsKHR::DECODE_H264.0, "DECODE_H264"),
6752 (VideoCodecOperationFlagsKHR::DECODE_H265.0, "DECODE_H265"),
6753 ];
6754 debug_flags(f, KNOWN, self.0)
6755 }
6756}
6757impl fmt::Debug for VideoCodingControlFlagsKHR {
6758 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6759 const KNOWN: &[(Flags, &str)] = &[
6760 (VideoCodingControlFlagsKHR::RESET.0, "RESET"),
6761 (
6762 VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL.0,
6763 "ENCODE_RATE_CONTROL",
6764 ),
6765 (
6766 VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL_LAYER.0,
6767 "ENCODE_RATE_CONTROL_LAYER",
6768 ),
6769 ];
6770 debug_flags(f, KNOWN, self.0)
6771 }
6772}
6773impl fmt::Debug for VideoComponentBitDepthFlagsKHR {
6774 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6775 const KNOWN: &[(Flags, &str)] = &[
6776 (VideoComponentBitDepthFlagsKHR::INVALID.0, "INVALID"),
6777 (VideoComponentBitDepthFlagsKHR::TYPE_8.0, "TYPE_8"),
6778 (VideoComponentBitDepthFlagsKHR::TYPE_10.0, "TYPE_10"),
6779 (VideoComponentBitDepthFlagsKHR::TYPE_12.0, "TYPE_12"),
6780 ];
6781 debug_flags(f, KNOWN, self.0)
6782 }
6783}
6784impl fmt::Debug for VideoDecodeCapabilityFlagsKHR {
6785 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6786 const KNOWN: &[(Flags, &str)] = &[
6787 (
6788 VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_COINCIDE.0,
6789 "DPB_AND_OUTPUT_COINCIDE",
6790 ),
6791 (
6792 VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_DISTINCT.0,
6793 "DPB_AND_OUTPUT_DISTINCT",
6794 ),
6795 ];
6796 debug_flags(f, KNOWN, self.0)
6797 }
6798}
6799impl fmt::Debug for VideoDecodeFlagsKHR {
6800 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6801 const KNOWN: &[(Flags, &str)] = &[];
6802 debug_flags(f, KNOWN, self.0)
6803 }
6804}
6805impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsKHR {
6806 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6807 const KNOWN: &[(Flags, &str)] = &[
6808 (
6809 VideoDecodeH264PictureLayoutFlagsKHR::PROGRESSIVE.0,
6810 "PROGRESSIVE",
6811 ),
6812 (
6813 VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_INTERLEAVED_LINES.0,
6814 "INTERLACED_INTERLEAVED_LINES",
6815 ),
6816 (
6817 VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_SEPARATE_PLANES.0,
6818 "INTERLACED_SEPARATE_PLANES",
6819 ),
6820 ];
6821 debug_flags(f, KNOWN, self.0)
6822 }
6823}
6824impl fmt::Debug for VideoDecodeUsageFlagsKHR {
6825 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6826 const KNOWN: &[(Flags, &str)] = &[
6827 (VideoDecodeUsageFlagsKHR::DEFAULT.0, "DEFAULT"),
6828 (VideoDecodeUsageFlagsKHR::TRANSCODING.0, "TRANSCODING"),
6829 (VideoDecodeUsageFlagsKHR::OFFLINE.0, "OFFLINE"),
6830 (VideoDecodeUsageFlagsKHR::STREAMING.0, "STREAMING"),
6831 ];
6832 debug_flags(f, KNOWN, self.0)
6833 }
6834}
6835impl fmt::Debug for VideoEncodeCapabilityFlagsKHR {
6836 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6837 const KNOWN: &[(Flags, &str)] = &[(
6838 VideoEncodeCapabilityFlagsKHR::PRECEDING_EXTERNALLY_ENCODED_BYTES.0,
6839 "PRECEDING_EXTERNALLY_ENCODED_BYTES",
6840 )];
6841 debug_flags(f, KNOWN, self.0)
6842 }
6843}
6844impl fmt::Debug for VideoEncodeContentFlagsKHR {
6845 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6846 const KNOWN: &[(Flags, &str)] = &[
6847 (VideoEncodeContentFlagsKHR::DEFAULT.0, "DEFAULT"),
6848 (VideoEncodeContentFlagsKHR::CAMERA.0, "CAMERA"),
6849 (VideoEncodeContentFlagsKHR::DESKTOP.0, "DESKTOP"),
6850 (VideoEncodeContentFlagsKHR::RENDERED.0, "RENDERED"),
6851 ];
6852 debug_flags(f, KNOWN, self.0)
6853 }
6854}
6855impl fmt::Debug for VideoEncodeFeedbackFlagsKHR {
6856 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6857 const KNOWN: &[(Flags, &str)] = &[
6858 (
6859 VideoEncodeFeedbackFlagsKHR::BITSTREAM_BUFFER_OFFSET.0,
6860 "BITSTREAM_BUFFER_OFFSET",
6861 ),
6862 (
6863 VideoEncodeFeedbackFlagsKHR::BITSTREAM_BYTES_WRITTEN.0,
6864 "BITSTREAM_BYTES_WRITTEN",
6865 ),
6866 ];
6867 debug_flags(f, KNOWN, self.0)
6868 }
6869}
6870impl fmt::Debug for VideoEncodeFlagsKHR {
6871 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6872 const KNOWN: &[(Flags, &str)] = &[];
6873 debug_flags(f, KNOWN, self.0)
6874 }
6875}
6876impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
6877 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6878 const KNOWN: &[(Flags, &str)] = &[
6879 (
6880 VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_ENABLED.0,
6881 "DIRECT_8X8_INFERENCE_ENABLED",
6882 ),
6883 (
6884 VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_DISABLED.0,
6885 "DIRECT_8X8_INFERENCE_DISABLED",
6886 ),
6887 (
6888 VideoEncodeH264CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0,
6889 "SEPARATE_COLOUR_PLANE",
6890 ),
6891 (
6892 VideoEncodeH264CapabilityFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS.0,
6893 "QPPRIME_Y_ZERO_TRANSFORM_BYPASS",
6894 ),
6895 (
6896 VideoEncodeH264CapabilityFlagsEXT::SCALING_LISTS.0,
6897 "SCALING_LISTS",
6898 ),
6899 (
6900 VideoEncodeH264CapabilityFlagsEXT::HRD_COMPLIANCE.0,
6901 "HRD_COMPLIANCE",
6902 ),
6903 (
6904 VideoEncodeH264CapabilityFlagsEXT::CHROMA_QP_OFFSET.0,
6905 "CHROMA_QP_OFFSET",
6906 ),
6907 (
6908 VideoEncodeH264CapabilityFlagsEXT::SECOND_CHROMA_QP_OFFSET.0,
6909 "SECOND_CHROMA_QP_OFFSET",
6910 ),
6911 (
6912 VideoEncodeH264CapabilityFlagsEXT::PIC_INIT_QP_MINUS26.0,
6913 "PIC_INIT_QP_MINUS26",
6914 ),
6915 (
6916 VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED.0,
6917 "WEIGHTED_PRED",
6918 ),
6919 (
6920 VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_EXPLICIT.0,
6921 "WEIGHTED_BIPRED_EXPLICIT",
6922 ),
6923 (
6924 VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_IMPLICIT.0,
6925 "WEIGHTED_BIPRED_IMPLICIT",
6926 ),
6927 (
6928 VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0,
6929 "WEIGHTED_PRED_NO_TABLE",
6930 ),
6931 (
6932 VideoEncodeH264CapabilityFlagsEXT::TRANSFORM_8X8.0,
6933 "TRANSFORM_8X8",
6934 ),
6935 (VideoEncodeH264CapabilityFlagsEXT::CABAC.0, "CABAC"),
6936 (VideoEncodeH264CapabilityFlagsEXT::CAVLC.0, "CAVLC"),
6937 (
6938 VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_DISABLED.0,
6939 "DEBLOCKING_FILTER_DISABLED",
6940 ),
6941 (
6942 VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_ENABLED.0,
6943 "DEBLOCKING_FILTER_ENABLED",
6944 ),
6945 (
6946 VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0,
6947 "DEBLOCKING_FILTER_PARTIAL",
6948 ),
6949 (
6950 VideoEncodeH264CapabilityFlagsEXT::DISABLE_DIRECT_SPATIAL_MV_PRED.0,
6951 "DISABLE_DIRECT_SPATIAL_MV_PRED",
6952 ),
6953 (
6954 VideoEncodeH264CapabilityFlagsEXT::MULTIPLE_SLICE_PER_FRAME.0,
6955 "MULTIPLE_SLICE_PER_FRAME",
6956 ),
6957 (
6958 VideoEncodeH264CapabilityFlagsEXT::SLICE_MB_COUNT.0,
6959 "SLICE_MB_COUNT",
6960 ),
6961 (
6962 VideoEncodeH264CapabilityFlagsEXT::ROW_UNALIGNED_SLICE.0,
6963 "ROW_UNALIGNED_SLICE",
6964 ),
6965 (
6966 VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0,
6967 "DIFFERENT_SLICE_TYPE",
6968 ),
6969 (
6970 VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0,
6971 "B_FRAME_IN_L1_LIST",
6972 ),
6973 (
6974 VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0,
6975 "DIFFERENT_REFERENCE_FINAL_LISTS",
6976 ),
6977 ];
6978 debug_flags(f, KNOWN, self.0)
6979 }
6980}
6981impl fmt::Debug for VideoEncodeH264RateControlStructureEXT {
6982 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6983 let name = match *self {
6984 Self::UNKNOWN => Some("UNKNOWN"),
6985 Self::FLAT => Some("FLAT"),
6986 Self::DYADIC => Some("DYADIC"),
6987 _ => None,
6988 };
6989 if let Some(x) = name {
6990 f.write_str(x)
6991 } else {
6992 self.0.fmt(f)
6993 }
6994 }
6995}
6996impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT {
6997 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6998 const KNOWN: &[(Flags, &str)] = &[
6999 (
7000 VideoEncodeH265CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0,
7001 "SEPARATE_COLOUR_PLANE",
7002 ),
7003 (
7004 VideoEncodeH265CapabilityFlagsEXT::SCALING_LISTS.0,
7005 "SCALING_LISTS",
7006 ),
7007 (
7008 VideoEncodeH265CapabilityFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED.0,
7009 "SAMPLE_ADAPTIVE_OFFSET_ENABLED",
7010 ),
7011 (
7012 VideoEncodeH265CapabilityFlagsEXT::PCM_ENABLE.0,
7013 "PCM_ENABLE",
7014 ),
7015 (
7016 VideoEncodeH265CapabilityFlagsEXT::SPS_TEMPORAL_MVP_ENABLED.0,
7017 "SPS_TEMPORAL_MVP_ENABLED",
7018 ),
7019 (
7020 VideoEncodeH265CapabilityFlagsEXT::HRD_COMPLIANCE.0,
7021 "HRD_COMPLIANCE",
7022 ),
7023 (
7024 VideoEncodeH265CapabilityFlagsEXT::INIT_QP_MINUS26.0,
7025 "INIT_QP_MINUS26",
7026 ),
7027 (
7028 VideoEncodeH265CapabilityFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0,
7029 "LOG2_PARALLEL_MERGE_LEVEL_MINUS2",
7030 ),
7031 (
7032 VideoEncodeH265CapabilityFlagsEXT::SIGN_DATA_HIDING_ENABLED.0,
7033 "SIGN_DATA_HIDING_ENABLED",
7034 ),
7035 (
7036 VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_ENABLED.0,
7037 "TRANSFORM_SKIP_ENABLED",
7038 ),
7039 (
7040 VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_DISABLED.0,
7041 "TRANSFORM_SKIP_DISABLED",
7042 ),
7043 (
7044 VideoEncodeH265CapabilityFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT.0,
7045 "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT",
7046 ),
7047 (
7048 VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED.0,
7049 "WEIGHTED_PRED",
7050 ),
7051 (
7052 VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_BIPRED.0,
7053 "WEIGHTED_BIPRED",
7054 ),
7055 (
7056 VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0,
7057 "WEIGHTED_PRED_NO_TABLE",
7058 ),
7059 (
7060 VideoEncodeH265CapabilityFlagsEXT::TRANSQUANT_BYPASS_ENABLED.0,
7061 "TRANSQUANT_BYPASS_ENABLED",
7062 ),
7063 (
7064 VideoEncodeH265CapabilityFlagsEXT::ENTROPY_CODING_SYNC_ENABLED.0,
7065 "ENTROPY_CODING_SYNC_ENABLED",
7066 ),
7067 (
7068 VideoEncodeH265CapabilityFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED.0,
7069 "DEBLOCKING_FILTER_OVERRIDE_ENABLED",
7070 ),
7071 (
7072 VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_FRAME.0,
7073 "MULTIPLE_TILE_PER_FRAME",
7074 ),
7075 (
7076 VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_PER_TILE.0,
7077 "MULTIPLE_SLICE_PER_TILE",
7078 ),
7079 (
7080 VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_SLICE.0,
7081 "MULTIPLE_TILE_PER_SLICE",
7082 ),
7083 (
7084 VideoEncodeH265CapabilityFlagsEXT::SLICE_SEGMENT_CTB_COUNT.0,
7085 "SLICE_SEGMENT_CTB_COUNT",
7086 ),
7087 (
7088 VideoEncodeH265CapabilityFlagsEXT::ROW_UNALIGNED_SLICE_SEGMENT.0,
7089 "ROW_UNALIGNED_SLICE_SEGMENT",
7090 ),
7091 (
7092 VideoEncodeH265CapabilityFlagsEXT::DEPENDENT_SLICE_SEGMENT.0,
7093 "DEPENDENT_SLICE_SEGMENT",
7094 ),
7095 (
7096 VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0,
7097 "DIFFERENT_SLICE_TYPE",
7098 ),
7099 (
7100 VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0,
7101 "B_FRAME_IN_L1_LIST",
7102 ),
7103 (
7104 VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0,
7105 "DIFFERENT_REFERENCE_FINAL_LISTS",
7106 ),
7107 ];
7108 debug_flags(f, KNOWN, self.0)
7109 }
7110}
7111impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT {
7112 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7113 const KNOWN: &[(Flags, &str)] = &[
7114 (VideoEncodeH265CtbSizeFlagsEXT::TYPE_16.0, "TYPE_16"),
7115 (VideoEncodeH265CtbSizeFlagsEXT::TYPE_32.0, "TYPE_32"),
7116 (VideoEncodeH265CtbSizeFlagsEXT::TYPE_64.0, "TYPE_64"),
7117 ];
7118 debug_flags(f, KNOWN, self.0)
7119 }
7120}
7121impl fmt::Debug for VideoEncodeH265RateControlStructureEXT {
7122 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7123 let name = match *self {
7124 Self::UNKNOWN => Some("UNKNOWN"),
7125 Self::FLAT => Some("FLAT"),
7126 Self::DYADIC => Some("DYADIC"),
7127 _ => None,
7128 };
7129 if let Some(x) = name {
7130 f.write_str(x)
7131 } else {
7132 self.0.fmt(f)
7133 }
7134 }
7135}
7136impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagsEXT {
7137 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7138 const KNOWN: &[(Flags, &str)] = &[
7139 (
7140 VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_4.0,
7141 "TYPE_4",
7142 ),
7143 (
7144 VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_8.0,
7145 "TYPE_8",
7146 ),
7147 (
7148 VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_16.0,
7149 "TYPE_16",
7150 ),
7151 (
7152 VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_32.0,
7153 "TYPE_32",
7154 ),
7155 ];
7156 debug_flags(f, KNOWN, self.0)
7157 }
7158}
7159impl fmt::Debug for VideoEncodeRateControlFlagsKHR {
7160 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7161 const KNOWN: &[(Flags, &str)] = &[];
7162 debug_flags(f, KNOWN, self.0)
7163 }
7164}
7165impl fmt::Debug for VideoEncodeRateControlModeFlagsKHR {
7166 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7167 const KNOWN: &[(Flags, &str)] = &[
7168 (VideoEncodeRateControlModeFlagsKHR::DEFAULT.0, "DEFAULT"),
7169 (VideoEncodeRateControlModeFlagsKHR::DISABLED.0, "DISABLED"),
7170 (VideoEncodeRateControlModeFlagsKHR::CBR.0, "CBR"),
7171 (VideoEncodeRateControlModeFlagsKHR::VBR.0, "VBR"),
7172 ];
7173 debug_flags(f, KNOWN, self.0)
7174 }
7175}
7176impl fmt::Debug for VideoEncodeTuningModeKHR {
7177 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7178 let name = match *self {
7179 Self::DEFAULT => Some("DEFAULT"),
7180 Self::HIGH_QUALITY => Some("HIGH_QUALITY"),
7181 Self::LOW_LATENCY => Some("LOW_LATENCY"),
7182 Self::ULTRA_LOW_LATENCY => Some("ULTRA_LOW_LATENCY"),
7183 Self::LOSSLESS => Some("LOSSLESS"),
7184 _ => None,
7185 };
7186 if let Some(x) = name {
7187 f.write_str(x)
7188 } else {
7189 self.0.fmt(f)
7190 }
7191 }
7192}
7193impl fmt::Debug for VideoEncodeUsageFlagsKHR {
7194 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7195 const KNOWN: &[(Flags, &str)] = &[
7196 (VideoEncodeUsageFlagsKHR::DEFAULT.0, "DEFAULT"),
7197 (VideoEncodeUsageFlagsKHR::TRANSCODING.0, "TRANSCODING"),
7198 (VideoEncodeUsageFlagsKHR::STREAMING.0, "STREAMING"),
7199 (VideoEncodeUsageFlagsKHR::RECORDING.0, "RECORDING"),
7200 (VideoEncodeUsageFlagsKHR::CONFERENCING.0, "CONFERENCING"),
7201 ];
7202 debug_flags(f, KNOWN, self.0)
7203 }
7204}
7205impl fmt::Debug for VideoEndCodingFlagsKHR {
7206 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7207 const KNOWN: &[(Flags, &str)] = &[];
7208 debug_flags(f, KNOWN, self.0)
7209 }
7210}
7211impl fmt::Debug for VideoSessionCreateFlagsKHR {
7212 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7213 const KNOWN: &[(Flags, &str)] = &[(
7214 VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0,
7215 "PROTECTED_CONTENT",
7216 )];
7217 debug_flags(f, KNOWN, self.0)
7218 }
7219}
7220impl fmt::Debug for VideoSessionParametersCreateFlagsKHR {
7221 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7222 const KNOWN: &[(Flags, &str)] = &[];
7223 debug_flags(f, KNOWN, self.0)
7224 }
7225}
7226impl fmt::Debug for ViewportCoordinateSwizzleNV {
7227 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7228 let name = match *self {
7229 Self::POSITIVE_X => Some("POSITIVE_X"),
7230 Self::NEGATIVE_X => Some("NEGATIVE_X"),
7231 Self::POSITIVE_Y => Some("POSITIVE_Y"),
7232 Self::NEGATIVE_Y => Some("NEGATIVE_Y"),
7233 Self::POSITIVE_Z => Some("POSITIVE_Z"),
7234 Self::NEGATIVE_Z => Some("NEGATIVE_Z"),
7235 Self::POSITIVE_W => Some("POSITIVE_W"),
7236 Self::NEGATIVE_W => Some("NEGATIVE_W"),
7237 _ => None,
7238 };
7239 if let Some(x) = name {
7240 f.write_str(x)
7241 } else {
7242 self.0.fmt(f)
7243 }
7244 }
7245}
7246impl fmt::Debug for WaylandSurfaceCreateFlagsKHR {
7247 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7248 const KNOWN: &[(Flags, &str)] = &[];
7249 debug_flags(f, KNOWN, self.0)
7250 }
7251}
7252impl fmt::Debug for Win32SurfaceCreateFlagsKHR {
7253 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7254 const KNOWN: &[(Flags, &str)] = &[];
7255 debug_flags(f, KNOWN, self.0)
7256 }
7257}
7258impl fmt::Debug for XcbSurfaceCreateFlagsKHR {
7259 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7260 const KNOWN: &[(Flags, &str)] = &[];
7261 debug_flags(f, KNOWN, self.0)
7262 }
7263}
7264impl fmt::Debug for XlibSurfaceCreateFlagsKHR {
7265 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7266 const KNOWN: &[(Flags, &str)] = &[];
7267 debug_flags(f, KNOWN, self.0)
7268 }
7269}