1 use crate::vk::bitflags::*;
2 use crate::vk::definitions::*;
3 use crate::vk::enums::*;
4 use std::fmt;
debug_flags( f: &mut fmt::Formatter, known: &[(Flags, &'static str)], value: Flags, ) -> fmt::Result5 pub(crate) fn debug_flags(
6 f: &mut fmt::Formatter,
7 known: &[(Flags, &'static str)],
8 value: Flags,
9 ) -> fmt::Result {
10 let mut first = true;
11 let mut accum = value;
12 for (bit, name) in known {
13 if *bit != 0 && accum & *bit == *bit {
14 if !first {
15 f.write_str(" | ")?;
16 }
17 f.write_str(name)?;
18 first = false;
19 accum &= !bit;
20 }
21 }
22 if accum != 0 {
23 if !first {
24 f.write_str(" | ")?;
25 }
26 write!(f, "{:b}", accum)?;
27 }
28 Ok(())
29 }
30 impl fmt::Debug for AccelerationStructureBuildTypeKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result31 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
32 let name = match *self {
33 Self::HOST => Some("HOST"),
34 Self::DEVICE => Some("DEVICE"),
35 Self::HOST_OR_DEVICE => Some("HOST_OR_DEVICE"),
36 _ => None,
37 };
38 if let Some(x) = name {
39 f.write_str(x)
40 } else {
41 self.0.fmt(f)
42 }
43 }
44 }
45 impl fmt::Debug for AccelerationStructureCompatibilityKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result46 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
47 let name = match *self {
48 Self::COMPATIBLE => Some("COMPATIBLE"),
49 Self::INCOMPATIBLE => Some("INCOMPATIBLE"),
50 _ => None,
51 };
52 if let Some(x) = name {
53 f.write_str(x)
54 } else {
55 self.0.fmt(f)
56 }
57 }
58 }
59 impl fmt::Debug for AccelerationStructureCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result60 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
61 const KNOWN: &[(Flags, &str)] = &[
62 (
63 AccelerationStructureCreateFlagsKHR::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
64 "DEVICE_ADDRESS_CAPTURE_REPLAY",
65 ),
66 (
67 AccelerationStructureCreateFlagsKHR::RESERVED_2_NV.0,
68 "RESERVED_2_NV",
69 ),
70 ];
71 debug_flags(f, KNOWN, self.0)
72 }
73 }
74 impl fmt::Debug for AccelerationStructureMemoryRequirementsTypeNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result75 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
76 let name = match *self {
77 Self::OBJECT => Some("OBJECT"),
78 Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"),
79 Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"),
80 _ => None,
81 };
82 if let Some(x) = name {
83 f.write_str(x)
84 } else {
85 self.0.fmt(f)
86 }
87 }
88 }
89 impl fmt::Debug for AccelerationStructureTypeKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result90 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
91 let name = match *self {
92 Self::TOP_LEVEL => Some("TOP_LEVEL"),
93 Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"),
94 Self::GENERIC => Some("GENERIC"),
95 _ => None,
96 };
97 if let Some(x) = name {
98 f.write_str(x)
99 } else {
100 self.0.fmt(f)
101 }
102 }
103 }
104 impl fmt::Debug for AccessFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result105 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
106 const KNOWN: &[(Flags, &str)] = &[
107 (
108 AccessFlags::INDIRECT_COMMAND_READ.0,
109 "INDIRECT_COMMAND_READ",
110 ),
111 (AccessFlags::INDEX_READ.0, "INDEX_READ"),
112 (
113 AccessFlags::VERTEX_ATTRIBUTE_READ.0,
114 "VERTEX_ATTRIBUTE_READ",
115 ),
116 (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"),
117 (
118 AccessFlags::INPUT_ATTACHMENT_READ.0,
119 "INPUT_ATTACHMENT_READ",
120 ),
121 (AccessFlags::SHADER_READ.0, "SHADER_READ"),
122 (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"),
123 (
124 AccessFlags::COLOR_ATTACHMENT_READ.0,
125 "COLOR_ATTACHMENT_READ",
126 ),
127 (
128 AccessFlags::COLOR_ATTACHMENT_WRITE.0,
129 "COLOR_ATTACHMENT_WRITE",
130 ),
131 (
132 AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0,
133 "DEPTH_STENCIL_ATTACHMENT_READ",
134 ),
135 (
136 AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0,
137 "DEPTH_STENCIL_ATTACHMENT_WRITE",
138 ),
139 (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"),
140 (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"),
141 (AccessFlags::HOST_READ.0, "HOST_READ"),
142 (AccessFlags::HOST_WRITE.0, "HOST_WRITE"),
143 (AccessFlags::MEMORY_READ.0, "MEMORY_READ"),
144 (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"),
145 (AccessFlags::RESERVED_30_KHR.0, "RESERVED_30_KHR"),
146 (AccessFlags::RESERVED_28_KHR.0, "RESERVED_28_KHR"),
147 (AccessFlags::RESERVED_29_KHR.0, "RESERVED_29_KHR"),
148 (
149 AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0,
150 "TRANSFORM_FEEDBACK_WRITE_EXT",
151 ),
152 (
153 AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0,
154 "TRANSFORM_FEEDBACK_COUNTER_READ_EXT",
155 ),
156 (
157 AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0,
158 "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT",
159 ),
160 (
161 AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0,
162 "CONDITIONAL_RENDERING_READ_EXT",
163 ),
164 (
165 AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0,
166 "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT",
167 ),
168 (
169 AccessFlags::ACCELERATION_STRUCTURE_READ_KHR.0,
170 "ACCELERATION_STRUCTURE_READ_KHR",
171 ),
172 (
173 AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR.0,
174 "ACCELERATION_STRUCTURE_WRITE_KHR",
175 ),
176 (
177 AccessFlags::SHADING_RATE_IMAGE_READ_NV.0,
178 "SHADING_RATE_IMAGE_READ_NV",
179 ),
180 (
181 AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0,
182 "FRAGMENT_DENSITY_MAP_READ_EXT",
183 ),
184 (
185 AccessFlags::COMMAND_PREPROCESS_READ_NV.0,
186 "COMMAND_PREPROCESS_READ_NV",
187 ),
188 (
189 AccessFlags::COMMAND_PREPROCESS_WRITE_NV.0,
190 "COMMAND_PREPROCESS_WRITE_NV",
191 ),
192 ];
193 debug_flags(f, KNOWN, self.0)
194 }
195 }
196 impl fmt::Debug for AcquireProfilingLockFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result197 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
198 const KNOWN: &[(Flags, &str)] = &[];
199 debug_flags(f, KNOWN, self.0)
200 }
201 }
202 impl fmt::Debug for AndroidSurfaceCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result203 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
204 const KNOWN: &[(Flags, &str)] = &[];
205 debug_flags(f, KNOWN, self.0)
206 }
207 }
208 impl fmt::Debug for AttachmentDescriptionFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result209 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
210 const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")];
211 debug_flags(f, KNOWN, self.0)
212 }
213 }
214 impl fmt::Debug for AttachmentLoadOp {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result215 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
216 let name = match *self {
217 Self::LOAD => Some("LOAD"),
218 Self::CLEAR => Some("CLEAR"),
219 Self::DONT_CARE => Some("DONT_CARE"),
220 _ => None,
221 };
222 if let Some(x) = name {
223 f.write_str(x)
224 } else {
225 self.0.fmt(f)
226 }
227 }
228 }
229 impl fmt::Debug for AttachmentStoreOp {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result230 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
231 let name = match *self {
232 Self::STORE => Some("STORE"),
233 Self::DONT_CARE => Some("DONT_CARE"),
234 Self::NONE_QCOM => Some("NONE_QCOM"),
235 _ => None,
236 };
237 if let Some(x) = name {
238 f.write_str(x)
239 } else {
240 self.0.fmt(f)
241 }
242 }
243 }
244 impl fmt::Debug for BlendFactor {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result245 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
246 let name = match *self {
247 Self::ZERO => Some("ZERO"),
248 Self::ONE => Some("ONE"),
249 Self::SRC_COLOR => Some("SRC_COLOR"),
250 Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"),
251 Self::DST_COLOR => Some("DST_COLOR"),
252 Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"),
253 Self::SRC_ALPHA => Some("SRC_ALPHA"),
254 Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"),
255 Self::DST_ALPHA => Some("DST_ALPHA"),
256 Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"),
257 Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"),
258 Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"),
259 Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"),
260 Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"),
261 Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"),
262 Self::SRC1_COLOR => Some("SRC1_COLOR"),
263 Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"),
264 Self::SRC1_ALPHA => Some("SRC1_ALPHA"),
265 Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"),
266 _ => None,
267 };
268 if let Some(x) = name {
269 f.write_str(x)
270 } else {
271 self.0.fmt(f)
272 }
273 }
274 }
275 impl fmt::Debug for BlendOp {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result276 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
277 let name = match *self {
278 Self::ADD => Some("ADD"),
279 Self::SUBTRACT => Some("SUBTRACT"),
280 Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"),
281 Self::MIN => Some("MIN"),
282 Self::MAX => Some("MAX"),
283 Self::ZERO_EXT => Some("ZERO_EXT"),
284 Self::SRC_EXT => Some("SRC_EXT"),
285 Self::DST_EXT => Some("DST_EXT"),
286 Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"),
287 Self::DST_OVER_EXT => Some("DST_OVER_EXT"),
288 Self::SRC_IN_EXT => Some("SRC_IN_EXT"),
289 Self::DST_IN_EXT => Some("DST_IN_EXT"),
290 Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"),
291 Self::DST_OUT_EXT => Some("DST_OUT_EXT"),
292 Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"),
293 Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"),
294 Self::XOR_EXT => Some("XOR_EXT"),
295 Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"),
296 Self::SCREEN_EXT => Some("SCREEN_EXT"),
297 Self::OVERLAY_EXT => Some("OVERLAY_EXT"),
298 Self::DARKEN_EXT => Some("DARKEN_EXT"),
299 Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"),
300 Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"),
301 Self::COLORBURN_EXT => Some("COLORBURN_EXT"),
302 Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"),
303 Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"),
304 Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"),
305 Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"),
306 Self::INVERT_EXT => Some("INVERT_EXT"),
307 Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"),
308 Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"),
309 Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"),
310 Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"),
311 Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"),
312 Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"),
313 Self::HARDMIX_EXT => Some("HARDMIX_EXT"),
314 Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"),
315 Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"),
316 Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"),
317 Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"),
318 Self::PLUS_EXT => Some("PLUS_EXT"),
319 Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"),
320 Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"),
321 Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"),
322 Self::MINUS_EXT => Some("MINUS_EXT"),
323 Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"),
324 Self::CONTRAST_EXT => Some("CONTRAST_EXT"),
325 Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"),
326 Self::RED_EXT => Some("RED_EXT"),
327 Self::GREEN_EXT => Some("GREEN_EXT"),
328 Self::BLUE_EXT => Some("BLUE_EXT"),
329 _ => None,
330 };
331 if let Some(x) = name {
332 f.write_str(x)
333 } else {
334 self.0.fmt(f)
335 }
336 }
337 }
338 impl fmt::Debug for BlendOverlapEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result339 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
340 let name = match *self {
341 Self::UNCORRELATED => Some("UNCORRELATED"),
342 Self::DISJOINT => Some("DISJOINT"),
343 Self::CONJOINT => Some("CONJOINT"),
344 _ => None,
345 };
346 if let Some(x) = name {
347 f.write_str(x)
348 } else {
349 self.0.fmt(f)
350 }
351 }
352 }
353 impl fmt::Debug for BorderColor {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result354 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
355 let name = match *self {
356 Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"),
357 Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"),
358 Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"),
359 Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"),
360 Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"),
361 Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"),
362 Self::FLOAT_CUSTOM_EXT => Some("FLOAT_CUSTOM_EXT"),
363 Self::INT_CUSTOM_EXT => Some("INT_CUSTOM_EXT"),
364 _ => None,
365 };
366 if let Some(x) = name {
367 f.write_str(x)
368 } else {
369 self.0.fmt(f)
370 }
371 }
372 }
373 impl fmt::Debug for BufferCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result374 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
375 const KNOWN: &[(Flags, &str)] = &[
376 (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"),
377 (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"),
378 (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"),
379 (BufferCreateFlags::RESERVED_5_NV.0, "RESERVED_5_NV"),
380 (BufferCreateFlags::PROTECTED.0, "PROTECTED"),
381 (
382 BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
383 "DEVICE_ADDRESS_CAPTURE_REPLAY",
384 ),
385 ];
386 debug_flags(f, KNOWN, self.0)
387 }
388 }
389 impl fmt::Debug for BufferUsageFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result390 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
391 const KNOWN: &[(Flags, &str)] = &[
392 (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"),
393 (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"),
394 (
395 BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0,
396 "UNIFORM_TEXEL_BUFFER",
397 ),
398 (
399 BufferUsageFlags::STORAGE_TEXEL_BUFFER.0,
400 "STORAGE_TEXEL_BUFFER",
401 ),
402 (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"),
403 (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"),
404 (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"),
405 (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"),
406 (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"),
407 (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"),
408 (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"),
409 (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"),
410 (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"),
411 (
412 BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0,
413 "TRANSFORM_FEEDBACK_BUFFER_EXT",
414 ),
415 (
416 BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0,
417 "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT",
418 ),
419 (
420 BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0,
421 "CONDITIONAL_RENDERING_EXT",
422 ),
423 (
424 BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0,
425 "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR",
426 ),
427 (
428 BufferUsageFlags::ACCELERATION_STRUCTURE_STORAGE_KHR.0,
429 "ACCELERATION_STRUCTURE_STORAGE_KHR",
430 ),
431 (
432 BufferUsageFlags::SHADER_BINDING_TABLE_KHR.0,
433 "SHADER_BINDING_TABLE_KHR",
434 ),
435 (BufferUsageFlags::RESERVED_18_QCOM.0, "RESERVED_18_QCOM"),
436 (
437 BufferUsageFlags::SHADER_DEVICE_ADDRESS.0,
438 "SHADER_DEVICE_ADDRESS",
439 ),
440 ];
441 debug_flags(f, KNOWN, self.0)
442 }
443 }
444 impl fmt::Debug for BufferViewCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result445 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
446 const KNOWN: &[(Flags, &str)] = &[];
447 debug_flags(f, KNOWN, self.0)
448 }
449 }
450 impl fmt::Debug for BuildAccelerationStructureFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result451 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
452 const KNOWN: &[(Flags, &str)] = &[
453 (
454 BuildAccelerationStructureFlagsKHR::ALLOW_UPDATE.0,
455 "ALLOW_UPDATE",
456 ),
457 (
458 BuildAccelerationStructureFlagsKHR::ALLOW_COMPACTION.0,
459 "ALLOW_COMPACTION",
460 ),
461 (
462 BuildAccelerationStructureFlagsKHR::PREFER_FAST_TRACE.0,
463 "PREFER_FAST_TRACE",
464 ),
465 (
466 BuildAccelerationStructureFlagsKHR::PREFER_FAST_BUILD.0,
467 "PREFER_FAST_BUILD",
468 ),
469 (
470 BuildAccelerationStructureFlagsKHR::LOW_MEMORY.0,
471 "LOW_MEMORY",
472 ),
473 (
474 BuildAccelerationStructureFlagsKHR::RESERVED_5_NV.0,
475 "RESERVED_5_NV",
476 ),
477 ];
478 debug_flags(f, KNOWN, self.0)
479 }
480 }
481 impl fmt::Debug for BuildAccelerationStructureModeKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result482 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
483 let name = match *self {
484 Self::BUILD => Some("BUILD"),
485 Self::UPDATE => Some("UPDATE"),
486 _ => None,
487 };
488 if let Some(x) = name {
489 f.write_str(x)
490 } else {
491 self.0.fmt(f)
492 }
493 }
494 }
495 impl fmt::Debug for ChromaLocation {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result496 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
497 let name = match *self {
498 Self::COSITED_EVEN => Some("COSITED_EVEN"),
499 Self::MIDPOINT => Some("MIDPOINT"),
500 _ => None,
501 };
502 if let Some(x) = name {
503 f.write_str(x)
504 } else {
505 self.0.fmt(f)
506 }
507 }
508 }
509 impl fmt::Debug for CoarseSampleOrderTypeNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result510 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
511 let name = match *self {
512 Self::DEFAULT => Some("DEFAULT"),
513 Self::CUSTOM => Some("CUSTOM"),
514 Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"),
515 Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"),
516 _ => None,
517 };
518 if let Some(x) = name {
519 f.write_str(x)
520 } else {
521 self.0.fmt(f)
522 }
523 }
524 }
525 impl fmt::Debug for ColorComponentFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result526 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
527 const KNOWN: &[(Flags, &str)] = &[
528 (ColorComponentFlags::R.0, "R"),
529 (ColorComponentFlags::G.0, "G"),
530 (ColorComponentFlags::B.0, "B"),
531 (ColorComponentFlags::A.0, "A"),
532 ];
533 debug_flags(f, KNOWN, self.0)
534 }
535 }
536 impl fmt::Debug for ColorSpaceKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result537 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
538 let name = match *self {
539 Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"),
540 Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"),
541 Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"),
542 Self::DISPLAY_P3_LINEAR_EXT => Some("DISPLAY_P3_LINEAR_EXT"),
543 Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"),
544 Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"),
545 Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"),
546 Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"),
547 Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"),
548 Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"),
549 Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"),
550 Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"),
551 Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"),
552 Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"),
553 Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"),
554 Self::DISPLAY_NATIVE_AMD => Some("DISPLAY_NATIVE_AMD"),
555 _ => None,
556 };
557 if let Some(x) = name {
558 f.write_str(x)
559 } else {
560 self.0.fmt(f)
561 }
562 }
563 }
564 impl fmt::Debug for CommandBufferLevel {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result565 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
566 let name = match *self {
567 Self::PRIMARY => Some("PRIMARY"),
568 Self::SECONDARY => Some("SECONDARY"),
569 _ => None,
570 };
571 if let Some(x) = name {
572 f.write_str(x)
573 } else {
574 self.0.fmt(f)
575 }
576 }
577 }
578 impl fmt::Debug for CommandBufferResetFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result579 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
580 const KNOWN: &[(Flags, &str)] = &[(
581 CommandBufferResetFlags::RELEASE_RESOURCES.0,
582 "RELEASE_RESOURCES",
583 )];
584 debug_flags(f, KNOWN, self.0)
585 }
586 }
587 impl fmt::Debug for CommandBufferUsageFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result588 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
589 const KNOWN: &[(Flags, &str)] = &[
590 (
591 CommandBufferUsageFlags::ONE_TIME_SUBMIT.0,
592 "ONE_TIME_SUBMIT",
593 ),
594 (
595 CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0,
596 "RENDER_PASS_CONTINUE",
597 ),
598 (
599 CommandBufferUsageFlags::SIMULTANEOUS_USE.0,
600 "SIMULTANEOUS_USE",
601 ),
602 ];
603 debug_flags(f, KNOWN, self.0)
604 }
605 }
606 impl fmt::Debug for CommandPoolCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result607 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
608 const KNOWN: &[(Flags, &str)] = &[
609 (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"),
610 (
611 CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0,
612 "RESET_COMMAND_BUFFER",
613 ),
614 (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"),
615 ];
616 debug_flags(f, KNOWN, self.0)
617 }
618 }
619 impl fmt::Debug for CommandPoolResetFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result620 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
621 const KNOWN: &[(Flags, &str)] = &[(
622 CommandPoolResetFlags::RELEASE_RESOURCES.0,
623 "RELEASE_RESOURCES",
624 )];
625 debug_flags(f, KNOWN, self.0)
626 }
627 }
628 impl fmt::Debug for CommandPoolTrimFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result629 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
630 const KNOWN: &[(Flags, &str)] = &[];
631 debug_flags(f, KNOWN, self.0)
632 }
633 }
634 impl fmt::Debug for CompareOp {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result635 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
636 let name = match *self {
637 Self::NEVER => Some("NEVER"),
638 Self::LESS => Some("LESS"),
639 Self::EQUAL => Some("EQUAL"),
640 Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"),
641 Self::GREATER => Some("GREATER"),
642 Self::NOT_EQUAL => Some("NOT_EQUAL"),
643 Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"),
644 Self::ALWAYS => Some("ALWAYS"),
645 _ => None,
646 };
647 if let Some(x) = name {
648 f.write_str(x)
649 } else {
650 self.0.fmt(f)
651 }
652 }
653 }
654 impl fmt::Debug for ComponentSwizzle {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result655 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
656 let name = match *self {
657 Self::IDENTITY => Some("IDENTITY"),
658 Self::ZERO => Some("ZERO"),
659 Self::ONE => Some("ONE"),
660 Self::R => Some("R"),
661 Self::G => Some("G"),
662 Self::B => Some("B"),
663 Self::A => Some("A"),
664 _ => None,
665 };
666 if let Some(x) = name {
667 f.write_str(x)
668 } else {
669 self.0.fmt(f)
670 }
671 }
672 }
673 impl fmt::Debug for ComponentTypeNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result674 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
675 let name = match *self {
676 Self::FLOAT16 => Some("FLOAT16"),
677 Self::FLOAT32 => Some("FLOAT32"),
678 Self::FLOAT64 => Some("FLOAT64"),
679 Self::SINT8 => Some("SINT8"),
680 Self::SINT16 => Some("SINT16"),
681 Self::SINT32 => Some("SINT32"),
682 Self::SINT64 => Some("SINT64"),
683 Self::UINT8 => Some("UINT8"),
684 Self::UINT16 => Some("UINT16"),
685 Self::UINT32 => Some("UINT32"),
686 Self::UINT64 => Some("UINT64"),
687 _ => None,
688 };
689 if let Some(x) = name {
690 f.write_str(x)
691 } else {
692 self.0.fmt(f)
693 }
694 }
695 }
696 impl fmt::Debug for CompositeAlphaFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result697 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
698 const KNOWN: &[(Flags, &str)] = &[
699 (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"),
700 (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"),
701 (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"),
702 (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"),
703 ];
704 debug_flags(f, KNOWN, self.0)
705 }
706 }
707 impl fmt::Debug for ConditionalRenderingFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result708 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
709 const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")];
710 debug_flags(f, KNOWN, self.0)
711 }
712 }
713 impl fmt::Debug for ConservativeRasterizationModeEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result714 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
715 let name = match *self {
716 Self::DISABLED => Some("DISABLED"),
717 Self::OVERESTIMATE => Some("OVERESTIMATE"),
718 Self::UNDERESTIMATE => Some("UNDERESTIMATE"),
719 _ => None,
720 };
721 if let Some(x) = name {
722 f.write_str(x)
723 } else {
724 self.0.fmt(f)
725 }
726 }
727 }
728 impl fmt::Debug for CopyAccelerationStructureModeKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result729 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
730 let name = match *self {
731 Self::CLONE => Some("CLONE"),
732 Self::COMPACT => Some("COMPACT"),
733 Self::SERIALIZE => Some("SERIALIZE"),
734 Self::DESERIALIZE => Some("DESERIALIZE"),
735 _ => None,
736 };
737 if let Some(x) = name {
738 f.write_str(x)
739 } else {
740 self.0.fmt(f)
741 }
742 }
743 }
744 impl fmt::Debug for CoverageModulationModeNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result745 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
746 let name = match *self {
747 Self::NONE => Some("NONE"),
748 Self::RGB => Some("RGB"),
749 Self::ALPHA => Some("ALPHA"),
750 Self::RGBA => Some("RGBA"),
751 _ => None,
752 };
753 if let Some(x) = name {
754 f.write_str(x)
755 } else {
756 self.0.fmt(f)
757 }
758 }
759 }
760 impl fmt::Debug for CoverageReductionModeNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result761 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
762 let name = match *self {
763 Self::MERGE => Some("MERGE"),
764 Self::TRUNCATE => Some("TRUNCATE"),
765 _ => None,
766 };
767 if let Some(x) = name {
768 f.write_str(x)
769 } else {
770 self.0.fmt(f)
771 }
772 }
773 }
774 impl fmt::Debug for CullModeFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result775 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
776 const KNOWN: &[(Flags, &str)] = &[
777 (CullModeFlags::NONE.0, "NONE"),
778 (CullModeFlags::FRONT.0, "FRONT"),
779 (CullModeFlags::BACK.0, "BACK"),
780 (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"),
781 ];
782 debug_flags(f, KNOWN, self.0)
783 }
784 }
785 impl fmt::Debug for DebugReportFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result786 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
787 const KNOWN: &[(Flags, &str)] = &[
788 (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"),
789 (DebugReportFlagsEXT::WARNING.0, "WARNING"),
790 (
791 DebugReportFlagsEXT::PERFORMANCE_WARNING.0,
792 "PERFORMANCE_WARNING",
793 ),
794 (DebugReportFlagsEXT::ERROR.0, "ERROR"),
795 (DebugReportFlagsEXT::DEBUG.0, "DEBUG"),
796 ];
797 debug_flags(f, KNOWN, self.0)
798 }
799 }
800 impl fmt::Debug for DebugReportObjectTypeEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result801 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
802 let name = match *self {
803 Self::UNKNOWN => Some("UNKNOWN"),
804 Self::INSTANCE => Some("INSTANCE"),
805 Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"),
806 Self::DEVICE => Some("DEVICE"),
807 Self::QUEUE => Some("QUEUE"),
808 Self::SEMAPHORE => Some("SEMAPHORE"),
809 Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"),
810 Self::FENCE => Some("FENCE"),
811 Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"),
812 Self::BUFFER => Some("BUFFER"),
813 Self::IMAGE => Some("IMAGE"),
814 Self::EVENT => Some("EVENT"),
815 Self::QUERY_POOL => Some("QUERY_POOL"),
816 Self::BUFFER_VIEW => Some("BUFFER_VIEW"),
817 Self::IMAGE_VIEW => Some("IMAGE_VIEW"),
818 Self::SHADER_MODULE => Some("SHADER_MODULE"),
819 Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"),
820 Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"),
821 Self::RENDER_PASS => Some("RENDER_PASS"),
822 Self::PIPELINE => Some("PIPELINE"),
823 Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"),
824 Self::SAMPLER => Some("SAMPLER"),
825 Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"),
826 Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"),
827 Self::FRAMEBUFFER => Some("FRAMEBUFFER"),
828 Self::COMMAND_POOL => Some("COMMAND_POOL"),
829 Self::SURFACE_KHR => Some("SURFACE_KHR"),
830 Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"),
831 Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"),
832 Self::DISPLAY_KHR => Some("DISPLAY_KHR"),
833 Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"),
834 Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"),
835 Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"),
836 Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"),
837 Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
838 Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
839 _ => None,
840 };
841 if let Some(x) = name {
842 f.write_str(x)
843 } else {
844 self.0.fmt(f)
845 }
846 }
847 }
848 impl fmt::Debug for DebugUtilsMessageSeverityFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result849 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
850 const KNOWN: &[(Flags, &str)] = &[
851 (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"),
852 (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"),
853 (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"),
854 (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"),
855 ];
856 debug_flags(f, KNOWN, self.0)
857 }
858 }
859 impl fmt::Debug for DebugUtilsMessageTypeFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result860 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
861 const KNOWN: &[(Flags, &str)] = &[
862 (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"),
863 (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"),
864 (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"),
865 ];
866 debug_flags(f, KNOWN, self.0)
867 }
868 }
869 impl fmt::Debug for DebugUtilsMessengerCallbackDataFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result870 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
871 const KNOWN: &[(Flags, &str)] = &[];
872 debug_flags(f, KNOWN, self.0)
873 }
874 }
875 impl fmt::Debug for DebugUtilsMessengerCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result876 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
877 const KNOWN: &[(Flags, &str)] = &[];
878 debug_flags(f, KNOWN, self.0)
879 }
880 }
881 impl fmt::Debug for DependencyFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result882 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
883 const KNOWN: &[(Flags, &str)] = &[
884 (DependencyFlags::BY_REGION.0, "BY_REGION"),
885 (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"),
886 (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"),
887 ];
888 debug_flags(f, KNOWN, self.0)
889 }
890 }
891 impl fmt::Debug for DescriptorBindingFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result892 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
893 const KNOWN: &[(Flags, &str)] = &[
894 (
895 DescriptorBindingFlags::UPDATE_AFTER_BIND.0,
896 "UPDATE_AFTER_BIND",
897 ),
898 (
899 DescriptorBindingFlags::UPDATE_UNUSED_WHILE_PENDING.0,
900 "UPDATE_UNUSED_WHILE_PENDING",
901 ),
902 (DescriptorBindingFlags::PARTIALLY_BOUND.0, "PARTIALLY_BOUND"),
903 (
904 DescriptorBindingFlags::VARIABLE_DESCRIPTOR_COUNT.0,
905 "VARIABLE_DESCRIPTOR_COUNT",
906 ),
907 (DescriptorBindingFlags::RESERVED_4_QCOM.0, "RESERVED_4_QCOM"),
908 ];
909 debug_flags(f, KNOWN, self.0)
910 }
911 }
912 impl fmt::Debug for DescriptorPoolCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result913 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
914 const KNOWN: &[(Flags, &str)] = &[
915 (
916 DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0,
917 "FREE_DESCRIPTOR_SET",
918 ),
919 (
920 DescriptorPoolCreateFlags::HOST_ONLY_VALVE.0,
921 "HOST_ONLY_VALVE",
922 ),
923 (
924 DescriptorPoolCreateFlags::UPDATE_AFTER_BIND.0,
925 "UPDATE_AFTER_BIND",
926 ),
927 ];
928 debug_flags(f, KNOWN, self.0)
929 }
930 }
931 impl fmt::Debug for DescriptorPoolResetFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result932 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
933 const KNOWN: &[(Flags, &str)] = &[];
934 debug_flags(f, KNOWN, self.0)
935 }
936 }
937 impl fmt::Debug for DescriptorSetLayoutCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result938 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
939 const KNOWN: &[(Flags, &str)] = &[
940 (
941 DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0,
942 "PUSH_DESCRIPTOR_KHR",
943 ),
944 (
945 DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_VALVE.0,
946 "HOST_ONLY_POOL_VALVE",
947 ),
948 (
949 DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL.0,
950 "UPDATE_AFTER_BIND_POOL",
951 ),
952 ];
953 debug_flags(f, KNOWN, self.0)
954 }
955 }
956 impl fmt::Debug for DescriptorType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result957 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
958 let name = match *self {
959 Self::SAMPLER => Some("SAMPLER"),
960 Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"),
961 Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"),
962 Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"),
963 Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"),
964 Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"),
965 Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"),
966 Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"),
967 Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"),
968 Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"),
969 Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"),
970 Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"),
971 Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
972 Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
973 Self::MUTABLE_VALVE => Some("MUTABLE_VALVE"),
974 _ => None,
975 };
976 if let Some(x) = name {
977 f.write_str(x)
978 } else {
979 self.0.fmt(f)
980 }
981 }
982 }
983 impl fmt::Debug for DescriptorUpdateTemplateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result984 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
985 const KNOWN: &[(Flags, &str)] = &[];
986 debug_flags(f, KNOWN, self.0)
987 }
988 }
989 impl fmt::Debug for DescriptorUpdateTemplateType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result990 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
991 let name = match *self {
992 Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"),
993 Self::PUSH_DESCRIPTORS_KHR => Some("PUSH_DESCRIPTORS_KHR"),
994 _ => None,
995 };
996 if let Some(x) = name {
997 f.write_str(x)
998 } else {
999 self.0.fmt(f)
1000 }
1001 }
1002 }
1003 impl fmt::Debug for DeviceCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1004 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1005 const KNOWN: &[(Flags, &str)] = &[];
1006 debug_flags(f, KNOWN, self.0)
1007 }
1008 }
1009 impl fmt::Debug for DeviceDiagnosticsConfigFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1010 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1011 const KNOWN: &[(Flags, &str)] = &[
1012 (
1013 DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_DEBUG_INFO.0,
1014 "ENABLE_SHADER_DEBUG_INFO",
1015 ),
1016 (
1017 DeviceDiagnosticsConfigFlagsNV::ENABLE_RESOURCE_TRACKING.0,
1018 "ENABLE_RESOURCE_TRACKING",
1019 ),
1020 (
1021 DeviceDiagnosticsConfigFlagsNV::ENABLE_AUTOMATIC_CHECKPOINTS.0,
1022 "ENABLE_AUTOMATIC_CHECKPOINTS",
1023 ),
1024 ];
1025 debug_flags(f, KNOWN, self.0)
1026 }
1027 }
1028 impl fmt::Debug for DeviceEventTypeEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1029 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1030 let name = match *self {
1031 Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"),
1032 _ => None,
1033 };
1034 if let Some(x) = name {
1035 f.write_str(x)
1036 } else {
1037 self.0.fmt(f)
1038 }
1039 }
1040 }
1041 impl fmt::Debug for DeviceGroupPresentModeFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1042 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1043 const KNOWN: &[(Flags, &str)] = &[
1044 (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"),
1045 (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"),
1046 (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"),
1047 (
1048 DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0,
1049 "LOCAL_MULTI_DEVICE",
1050 ),
1051 ];
1052 debug_flags(f, KNOWN, self.0)
1053 }
1054 }
1055 impl fmt::Debug for DeviceMemoryReportEventTypeEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1056 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1057 let name = match *self {
1058 Self::ALLOCATE => Some("ALLOCATE"),
1059 Self::FREE => Some("FREE"),
1060 Self::IMPORT => Some("IMPORT"),
1061 Self::UNIMPORT => Some("UNIMPORT"),
1062 Self::ALLOCATION_FAILED => Some("ALLOCATION_FAILED"),
1063 _ => None,
1064 };
1065 if let Some(x) = name {
1066 f.write_str(x)
1067 } else {
1068 self.0.fmt(f)
1069 }
1070 }
1071 }
1072 impl fmt::Debug for DeviceMemoryReportFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1073 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1074 const KNOWN: &[(Flags, &str)] = &[];
1075 debug_flags(f, KNOWN, self.0)
1076 }
1077 }
1078 impl fmt::Debug for DeviceQueueCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1079 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1080 const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")];
1081 debug_flags(f, KNOWN, self.0)
1082 }
1083 }
1084 impl fmt::Debug for DirectFBSurfaceCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1085 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1086 const KNOWN: &[(Flags, &str)] = &[];
1087 debug_flags(f, KNOWN, self.0)
1088 }
1089 }
1090 impl fmt::Debug for DiscardRectangleModeEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1091 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1092 let name = match *self {
1093 Self::INCLUSIVE => Some("INCLUSIVE"),
1094 Self::EXCLUSIVE => Some("EXCLUSIVE"),
1095 _ => None,
1096 };
1097 if let Some(x) = name {
1098 f.write_str(x)
1099 } else {
1100 self.0.fmt(f)
1101 }
1102 }
1103 }
1104 impl fmt::Debug for DisplayEventTypeEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1105 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1106 let name = match *self {
1107 Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"),
1108 _ => None,
1109 };
1110 if let Some(x) = name {
1111 f.write_str(x)
1112 } else {
1113 self.0.fmt(f)
1114 }
1115 }
1116 }
1117 impl fmt::Debug for DisplayModeCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1118 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1119 const KNOWN: &[(Flags, &str)] = &[];
1120 debug_flags(f, KNOWN, self.0)
1121 }
1122 }
1123 impl fmt::Debug for DisplayPlaneAlphaFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1124 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1125 const KNOWN: &[(Flags, &str)] = &[
1126 (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"),
1127 (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"),
1128 (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"),
1129 (
1130 DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0,
1131 "PER_PIXEL_PREMULTIPLIED",
1132 ),
1133 ];
1134 debug_flags(f, KNOWN, self.0)
1135 }
1136 }
1137 impl fmt::Debug for DisplayPowerStateEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1138 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1139 let name = match *self {
1140 Self::OFF => Some("OFF"),
1141 Self::SUSPEND => Some("SUSPEND"),
1142 Self::ON => Some("ON"),
1143 _ => None,
1144 };
1145 if let Some(x) = name {
1146 f.write_str(x)
1147 } else {
1148 self.0.fmt(f)
1149 }
1150 }
1151 }
1152 impl fmt::Debug for DisplaySurfaceCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1153 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1154 const KNOWN: &[(Flags, &str)] = &[];
1155 debug_flags(f, KNOWN, self.0)
1156 }
1157 }
1158 impl fmt::Debug for DriverId {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1159 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1160 let name = match *self {
1161 Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"),
1162 Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"),
1163 Self::MESA_RADV => Some("MESA_RADV"),
1164 Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"),
1165 Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"),
1166 Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"),
1167 Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"),
1168 Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"),
1169 Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"),
1170 Self::GOOGLE_SWIFTSHADER => Some("GOOGLE_SWIFTSHADER"),
1171 Self::GGP_PROPRIETARY => Some("GGP_PROPRIETARY"),
1172 Self::BROADCOM_PROPRIETARY => Some("BROADCOM_PROPRIETARY"),
1173 Self::MESA_LLVMPIPE => Some("MESA_LLVMPIPE"),
1174 Self::MOLTENVK => Some("MOLTENVK"),
1175 _ => None,
1176 };
1177 if let Some(x) = name {
1178 f.write_str(x)
1179 } else {
1180 self.0.fmt(f)
1181 }
1182 }
1183 }
1184 impl fmt::Debug for DynamicState {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1185 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1186 let name = match *self {
1187 Self::VIEWPORT => Some("VIEWPORT"),
1188 Self::SCISSOR => Some("SCISSOR"),
1189 Self::LINE_WIDTH => Some("LINE_WIDTH"),
1190 Self::DEPTH_BIAS => Some("DEPTH_BIAS"),
1191 Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"),
1192 Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"),
1193 Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"),
1194 Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"),
1195 Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"),
1196 Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"),
1197 Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"),
1198 Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"),
1199 Self::RAY_TRACING_PIPELINE_STACK_SIZE_KHR => {
1200 Some("RAY_TRACING_PIPELINE_STACK_SIZE_KHR")
1201 }
1202 Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"),
1203 Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"),
1204 Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"),
1205 Self::FRAGMENT_SHADING_RATE_KHR => Some("FRAGMENT_SHADING_RATE_KHR"),
1206 Self::LINE_STIPPLE_EXT => Some("LINE_STIPPLE_EXT"),
1207 Self::CULL_MODE_EXT => Some("CULL_MODE_EXT"),
1208 Self::FRONT_FACE_EXT => Some("FRONT_FACE_EXT"),
1209 Self::PRIMITIVE_TOPOLOGY_EXT => Some("PRIMITIVE_TOPOLOGY_EXT"),
1210 Self::VIEWPORT_WITH_COUNT_EXT => Some("VIEWPORT_WITH_COUNT_EXT"),
1211 Self::SCISSOR_WITH_COUNT_EXT => Some("SCISSOR_WITH_COUNT_EXT"),
1212 Self::VERTEX_INPUT_BINDING_STRIDE_EXT => Some("VERTEX_INPUT_BINDING_STRIDE_EXT"),
1213 Self::DEPTH_TEST_ENABLE_EXT => Some("DEPTH_TEST_ENABLE_EXT"),
1214 Self::DEPTH_WRITE_ENABLE_EXT => Some("DEPTH_WRITE_ENABLE_EXT"),
1215 Self::DEPTH_COMPARE_OP_EXT => Some("DEPTH_COMPARE_OP_EXT"),
1216 Self::DEPTH_BOUNDS_TEST_ENABLE_EXT => Some("DEPTH_BOUNDS_TEST_ENABLE_EXT"),
1217 Self::STENCIL_TEST_ENABLE_EXT => Some("STENCIL_TEST_ENABLE_EXT"),
1218 Self::STENCIL_OP_EXT => Some("STENCIL_OP_EXT"),
1219 _ => None,
1220 };
1221 if let Some(x) = name {
1222 f.write_str(x)
1223 } else {
1224 self.0.fmt(f)
1225 }
1226 }
1227 }
1228 impl fmt::Debug for EventCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1229 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1230 const KNOWN: &[(Flags, &str)] = &[];
1231 debug_flags(f, KNOWN, self.0)
1232 }
1233 }
1234 impl fmt::Debug for ExternalFenceFeatureFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1235 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1236 const KNOWN: &[(Flags, &str)] = &[
1237 (ExternalFenceFeatureFlags::EXPORTABLE.0, "EXPORTABLE"),
1238 (ExternalFenceFeatureFlags::IMPORTABLE.0, "IMPORTABLE"),
1239 ];
1240 debug_flags(f, KNOWN, self.0)
1241 }
1242 }
1243 impl fmt::Debug for ExternalFenceHandleTypeFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1244 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1245 const KNOWN: &[(Flags, &str)] = &[
1246 (ExternalFenceHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"),
1247 (ExternalFenceHandleTypeFlags::OPAQUE_WIN32.0, "OPAQUE_WIN32"),
1248 (
1249 ExternalFenceHandleTypeFlags::OPAQUE_WIN32_KMT.0,
1250 "OPAQUE_WIN32_KMT",
1251 ),
1252 (ExternalFenceHandleTypeFlags::SYNC_FD.0, "SYNC_FD"),
1253 (
1254 ExternalFenceHandleTypeFlags::RESERVED_4_NV.0,
1255 "RESERVED_4_NV",
1256 ),
1257 (
1258 ExternalFenceHandleTypeFlags::RESERVED_5_NV.0,
1259 "RESERVED_5_NV",
1260 ),
1261 ];
1262 debug_flags(f, KNOWN, self.0)
1263 }
1264 }
1265 impl fmt::Debug for ExternalMemoryFeatureFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1266 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1267 const KNOWN: &[(Flags, &str)] = &[
1268 (
1269 ExternalMemoryFeatureFlags::DEDICATED_ONLY.0,
1270 "DEDICATED_ONLY",
1271 ),
1272 (ExternalMemoryFeatureFlags::EXPORTABLE.0, "EXPORTABLE"),
1273 (ExternalMemoryFeatureFlags::IMPORTABLE.0, "IMPORTABLE"),
1274 ];
1275 debug_flags(f, KNOWN, self.0)
1276 }
1277 }
1278 impl fmt::Debug for ExternalMemoryFeatureFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1279 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1280 const KNOWN: &[(Flags, &str)] = &[
1281 (
1282 ExternalMemoryFeatureFlagsNV::DEDICATED_ONLY.0,
1283 "DEDICATED_ONLY",
1284 ),
1285 (ExternalMemoryFeatureFlagsNV::EXPORTABLE.0, "EXPORTABLE"),
1286 (ExternalMemoryFeatureFlagsNV::IMPORTABLE.0, "IMPORTABLE"),
1287 ];
1288 debug_flags(f, KNOWN, self.0)
1289 }
1290 }
1291 impl fmt::Debug for ExternalMemoryHandleTypeFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1292 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1293 const KNOWN: &[(Flags, &str)] = &[
1294 (ExternalMemoryHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"),
1295 (
1296 ExternalMemoryHandleTypeFlags::OPAQUE_WIN32.0,
1297 "OPAQUE_WIN32",
1298 ),
1299 (
1300 ExternalMemoryHandleTypeFlags::OPAQUE_WIN32_KMT.0,
1301 "OPAQUE_WIN32_KMT",
1302 ),
1303 (
1304 ExternalMemoryHandleTypeFlags::D3D11_TEXTURE.0,
1305 "D3D11_TEXTURE",
1306 ),
1307 (
1308 ExternalMemoryHandleTypeFlags::D3D11_TEXTURE_KMT.0,
1309 "D3D11_TEXTURE_KMT",
1310 ),
1311 (ExternalMemoryHandleTypeFlags::D3D12_HEAP.0, "D3D12_HEAP"),
1312 (
1313 ExternalMemoryHandleTypeFlags::D3D12_RESOURCE.0,
1314 "D3D12_RESOURCE",
1315 ),
1316 (ExternalMemoryHandleTypeFlags::DMA_BUF_EXT.0, "DMA_BUF_EXT"),
1317 (
1318 ExternalMemoryHandleTypeFlags::ANDROID_HARDWARE_BUFFER_ANDROID.0,
1319 "ANDROID_HARDWARE_BUFFER_ANDROID",
1320 ),
1321 (
1322 ExternalMemoryHandleTypeFlags::HOST_ALLOCATION_EXT.0,
1323 "HOST_ALLOCATION_EXT",
1324 ),
1325 (
1326 ExternalMemoryHandleTypeFlags::HOST_MAPPED_FOREIGN_MEMORY_EXT.0,
1327 "HOST_MAPPED_FOREIGN_MEMORY_EXT",
1328 ),
1329 ];
1330 debug_flags(f, KNOWN, self.0)
1331 }
1332 }
1333 impl fmt::Debug for ExternalMemoryHandleTypeFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1334 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1335 const KNOWN: &[(Flags, &str)] = &[
1336 (
1337 ExternalMemoryHandleTypeFlagsNV::OPAQUE_WIN32.0,
1338 "OPAQUE_WIN32",
1339 ),
1340 (
1341 ExternalMemoryHandleTypeFlagsNV::OPAQUE_WIN32_KMT.0,
1342 "OPAQUE_WIN32_KMT",
1343 ),
1344 (
1345 ExternalMemoryHandleTypeFlagsNV::D3D11_IMAGE.0,
1346 "D3D11_IMAGE",
1347 ),
1348 (
1349 ExternalMemoryHandleTypeFlagsNV::D3D11_IMAGE_KMT.0,
1350 "D3D11_IMAGE_KMT",
1351 ),
1352 ];
1353 debug_flags(f, KNOWN, self.0)
1354 }
1355 }
1356 impl fmt::Debug for ExternalSemaphoreFeatureFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1357 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1358 const KNOWN: &[(Flags, &str)] = &[
1359 (ExternalSemaphoreFeatureFlags::EXPORTABLE.0, "EXPORTABLE"),
1360 (ExternalSemaphoreFeatureFlags::IMPORTABLE.0, "IMPORTABLE"),
1361 ];
1362 debug_flags(f, KNOWN, self.0)
1363 }
1364 }
1365 impl fmt::Debug for ExternalSemaphoreHandleTypeFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1366 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1367 const KNOWN: &[(Flags, &str)] = &[
1368 (ExternalSemaphoreHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"),
1369 (
1370 ExternalSemaphoreHandleTypeFlags::OPAQUE_WIN32.0,
1371 "OPAQUE_WIN32",
1372 ),
1373 (
1374 ExternalSemaphoreHandleTypeFlags::OPAQUE_WIN32_KMT.0,
1375 "OPAQUE_WIN32_KMT",
1376 ),
1377 (
1378 ExternalSemaphoreHandleTypeFlags::D3D12_FENCE.0,
1379 "D3D12_FENCE",
1380 ),
1381 (ExternalSemaphoreHandleTypeFlags::SYNC_FD.0, "SYNC_FD"),
1382 (
1383 ExternalSemaphoreHandleTypeFlags::RESERVED_5_NV.0,
1384 "RESERVED_5_NV",
1385 ),
1386 (
1387 ExternalSemaphoreHandleTypeFlags::RESERVED_6_NV.0,
1388 "RESERVED_6_NV",
1389 ),
1390 ];
1391 debug_flags(f, KNOWN, self.0)
1392 }
1393 }
1394 impl fmt::Debug for FenceCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1395 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1396 const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")];
1397 debug_flags(f, KNOWN, self.0)
1398 }
1399 }
1400 impl fmt::Debug for FenceImportFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1401 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1402 const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")];
1403 debug_flags(f, KNOWN, self.0)
1404 }
1405 }
1406 impl fmt::Debug for Filter {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1407 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1408 let name = match *self {
1409 Self::NEAREST => Some("NEAREST"),
1410 Self::LINEAR => Some("LINEAR"),
1411 Self::CUBIC_IMG => Some("CUBIC_IMG"),
1412 _ => None,
1413 };
1414 if let Some(x) = name {
1415 f.write_str(x)
1416 } else {
1417 self.0.fmt(f)
1418 }
1419 }
1420 }
1421 impl fmt::Debug for Format {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1422 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1423 let name = match *self {
1424 Self::UNDEFINED => Some("UNDEFINED"),
1425 Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"),
1426 Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"),
1427 Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"),
1428 Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"),
1429 Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"),
1430 Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"),
1431 Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"),
1432 Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"),
1433 Self::R8_UNORM => Some("R8_UNORM"),
1434 Self::R8_SNORM => Some("R8_SNORM"),
1435 Self::R8_USCALED => Some("R8_USCALED"),
1436 Self::R8_SSCALED => Some("R8_SSCALED"),
1437 Self::R8_UINT => Some("R8_UINT"),
1438 Self::R8_SINT => Some("R8_SINT"),
1439 Self::R8_SRGB => Some("R8_SRGB"),
1440 Self::R8G8_UNORM => Some("R8G8_UNORM"),
1441 Self::R8G8_SNORM => Some("R8G8_SNORM"),
1442 Self::R8G8_USCALED => Some("R8G8_USCALED"),
1443 Self::R8G8_SSCALED => Some("R8G8_SSCALED"),
1444 Self::R8G8_UINT => Some("R8G8_UINT"),
1445 Self::R8G8_SINT => Some("R8G8_SINT"),
1446 Self::R8G8_SRGB => Some("R8G8_SRGB"),
1447 Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"),
1448 Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"),
1449 Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"),
1450 Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"),
1451 Self::R8G8B8_UINT => Some("R8G8B8_UINT"),
1452 Self::R8G8B8_SINT => Some("R8G8B8_SINT"),
1453 Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"),
1454 Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"),
1455 Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"),
1456 Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"),
1457 Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"),
1458 Self::B8G8R8_UINT => Some("B8G8R8_UINT"),
1459 Self::B8G8R8_SINT => Some("B8G8R8_SINT"),
1460 Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"),
1461 Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"),
1462 Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"),
1463 Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"),
1464 Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"),
1465 Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"),
1466 Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"),
1467 Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"),
1468 Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"),
1469 Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"),
1470 Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"),
1471 Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"),
1472 Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"),
1473 Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"),
1474 Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"),
1475 Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"),
1476 Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"),
1477 Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"),
1478 Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"),
1479 Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"),
1480 Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"),
1481 Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"),
1482 Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"),
1483 Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"),
1484 Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"),
1485 Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"),
1486 Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"),
1487 Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"),
1488 Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"),
1489 Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"),
1490 Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"),
1491 Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"),
1492 Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"),
1493 Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"),
1494 Self::R16_UNORM => Some("R16_UNORM"),
1495 Self::R16_SNORM => Some("R16_SNORM"),
1496 Self::R16_USCALED => Some("R16_USCALED"),
1497 Self::R16_SSCALED => Some("R16_SSCALED"),
1498 Self::R16_UINT => Some("R16_UINT"),
1499 Self::R16_SINT => Some("R16_SINT"),
1500 Self::R16_SFLOAT => Some("R16_SFLOAT"),
1501 Self::R16G16_UNORM => Some("R16G16_UNORM"),
1502 Self::R16G16_SNORM => Some("R16G16_SNORM"),
1503 Self::R16G16_USCALED => Some("R16G16_USCALED"),
1504 Self::R16G16_SSCALED => Some("R16G16_SSCALED"),
1505 Self::R16G16_UINT => Some("R16G16_UINT"),
1506 Self::R16G16_SINT => Some("R16G16_SINT"),
1507 Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"),
1508 Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"),
1509 Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"),
1510 Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"),
1511 Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"),
1512 Self::R16G16B16_UINT => Some("R16G16B16_UINT"),
1513 Self::R16G16B16_SINT => Some("R16G16B16_SINT"),
1514 Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"),
1515 Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"),
1516 Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"),
1517 Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"),
1518 Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"),
1519 Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"),
1520 Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"),
1521 Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"),
1522 Self::R32_UINT => Some("R32_UINT"),
1523 Self::R32_SINT => Some("R32_SINT"),
1524 Self::R32_SFLOAT => Some("R32_SFLOAT"),
1525 Self::R32G32_UINT => Some("R32G32_UINT"),
1526 Self::R32G32_SINT => Some("R32G32_SINT"),
1527 Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"),
1528 Self::R32G32B32_UINT => Some("R32G32B32_UINT"),
1529 Self::R32G32B32_SINT => Some("R32G32B32_SINT"),
1530 Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"),
1531 Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"),
1532 Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"),
1533 Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"),
1534 Self::R64_UINT => Some("R64_UINT"),
1535 Self::R64_SINT => Some("R64_SINT"),
1536 Self::R64_SFLOAT => Some("R64_SFLOAT"),
1537 Self::R64G64_UINT => Some("R64G64_UINT"),
1538 Self::R64G64_SINT => Some("R64G64_SINT"),
1539 Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"),
1540 Self::R64G64B64_UINT => Some("R64G64B64_UINT"),
1541 Self::R64G64B64_SINT => Some("R64G64B64_SINT"),
1542 Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"),
1543 Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"),
1544 Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"),
1545 Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"),
1546 Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"),
1547 Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"),
1548 Self::D16_UNORM => Some("D16_UNORM"),
1549 Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"),
1550 Self::D32_SFLOAT => Some("D32_SFLOAT"),
1551 Self::S8_UINT => Some("S8_UINT"),
1552 Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"),
1553 Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"),
1554 Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"),
1555 Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"),
1556 Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"),
1557 Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"),
1558 Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"),
1559 Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"),
1560 Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"),
1561 Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"),
1562 Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"),
1563 Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"),
1564 Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"),
1565 Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"),
1566 Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"),
1567 Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"),
1568 Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"),
1569 Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"),
1570 Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"),
1571 Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"),
1572 Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"),
1573 Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"),
1574 Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"),
1575 Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"),
1576 Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"),
1577 Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"),
1578 Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"),
1579 Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"),
1580 Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"),
1581 Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"),
1582 Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"),
1583 Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"),
1584 Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"),
1585 Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"),
1586 Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"),
1587 Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"),
1588 Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"),
1589 Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"),
1590 Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"),
1591 Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"),
1592 Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"),
1593 Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"),
1594 Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"),
1595 Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"),
1596 Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"),
1597 Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"),
1598 Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"),
1599 Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"),
1600 Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"),
1601 Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"),
1602 Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"),
1603 Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"),
1604 Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"),
1605 Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"),
1606 Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"),
1607 Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"),
1608 Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"),
1609 Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"),
1610 Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"),
1611 Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"),
1612 Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"),
1613 Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"),
1614 Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"),
1615 Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"),
1616 Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"),
1617 Self::ASTC_4X4_SFLOAT_BLOCK_EXT => Some("ASTC_4X4_SFLOAT_BLOCK_EXT"),
1618 Self::ASTC_5X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X4_SFLOAT_BLOCK_EXT"),
1619 Self::ASTC_5X5_SFLOAT_BLOCK_EXT => Some("ASTC_5X5_SFLOAT_BLOCK_EXT"),
1620 Self::ASTC_6X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X5_SFLOAT_BLOCK_EXT"),
1621 Self::ASTC_6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6_SFLOAT_BLOCK_EXT"),
1622 Self::ASTC_8X5_SFLOAT_BLOCK_EXT => Some("ASTC_8X5_SFLOAT_BLOCK_EXT"),
1623 Self::ASTC_8X6_SFLOAT_BLOCK_EXT => Some("ASTC_8X6_SFLOAT_BLOCK_EXT"),
1624 Self::ASTC_8X8_SFLOAT_BLOCK_EXT => Some("ASTC_8X8_SFLOAT_BLOCK_EXT"),
1625 Self::ASTC_10X5_SFLOAT_BLOCK_EXT => Some("ASTC_10X5_SFLOAT_BLOCK_EXT"),
1626 Self::ASTC_10X6_SFLOAT_BLOCK_EXT => Some("ASTC_10X6_SFLOAT_BLOCK_EXT"),
1627 Self::ASTC_10X8_SFLOAT_BLOCK_EXT => Some("ASTC_10X8_SFLOAT_BLOCK_EXT"),
1628 Self::ASTC_10X10_SFLOAT_BLOCK_EXT => Some("ASTC_10X10_SFLOAT_BLOCK_EXT"),
1629 Self::ASTC_12X10_SFLOAT_BLOCK_EXT => Some("ASTC_12X10_SFLOAT_BLOCK_EXT"),
1630 Self::ASTC_12X12_SFLOAT_BLOCK_EXT => Some("ASTC_12X12_SFLOAT_BLOCK_EXT"),
1631 Self::ASTC_3X3X3_UNORM_BLOCK_EXT => Some("ASTC_3X3X3_UNORM_BLOCK_EXT"),
1632 Self::ASTC_3X3X3_SRGB_BLOCK_EXT => Some("ASTC_3X3X3_SRGB_BLOCK_EXT"),
1633 Self::ASTC_3X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_3X3X3_SFLOAT_BLOCK_EXT"),
1634 Self::ASTC_4X3X3_UNORM_BLOCK_EXT => Some("ASTC_4X3X3_UNORM_BLOCK_EXT"),
1635 Self::ASTC_4X3X3_SRGB_BLOCK_EXT => Some("ASTC_4X3X3_SRGB_BLOCK_EXT"),
1636 Self::ASTC_4X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X3X3_SFLOAT_BLOCK_EXT"),
1637 Self::ASTC_4X4X3_UNORM_BLOCK_EXT => Some("ASTC_4X4X3_UNORM_BLOCK_EXT"),
1638 Self::ASTC_4X4X3_SRGB_BLOCK_EXT => Some("ASTC_4X4X3_SRGB_BLOCK_EXT"),
1639 Self::ASTC_4X4X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X3_SFLOAT_BLOCK_EXT"),
1640 Self::ASTC_4X4X4_UNORM_BLOCK_EXT => Some("ASTC_4X4X4_UNORM_BLOCK_EXT"),
1641 Self::ASTC_4X4X4_SRGB_BLOCK_EXT => Some("ASTC_4X4X4_SRGB_BLOCK_EXT"),
1642 Self::ASTC_4X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X4_SFLOAT_BLOCK_EXT"),
1643 Self::ASTC_5X4X4_UNORM_BLOCK_EXT => Some("ASTC_5X4X4_UNORM_BLOCK_EXT"),
1644 Self::ASTC_5X4X4_SRGB_BLOCK_EXT => Some("ASTC_5X4X4_SRGB_BLOCK_EXT"),
1645 Self::ASTC_5X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X4X4_SFLOAT_BLOCK_EXT"),
1646 Self::ASTC_5X5X4_UNORM_BLOCK_EXT => Some("ASTC_5X5X4_UNORM_BLOCK_EXT"),
1647 Self::ASTC_5X5X4_SRGB_BLOCK_EXT => Some("ASTC_5X5X4_SRGB_BLOCK_EXT"),
1648 Self::ASTC_5X5X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X4_SFLOAT_BLOCK_EXT"),
1649 Self::ASTC_5X5X5_UNORM_BLOCK_EXT => Some("ASTC_5X5X5_UNORM_BLOCK_EXT"),
1650 Self::ASTC_5X5X5_SRGB_BLOCK_EXT => Some("ASTC_5X5X5_SRGB_BLOCK_EXT"),
1651 Self::ASTC_5X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X5_SFLOAT_BLOCK_EXT"),
1652 Self::ASTC_6X5X5_UNORM_BLOCK_EXT => Some("ASTC_6X5X5_UNORM_BLOCK_EXT"),
1653 Self::ASTC_6X5X5_SRGB_BLOCK_EXT => Some("ASTC_6X5X5_SRGB_BLOCK_EXT"),
1654 Self::ASTC_6X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X5X5_SFLOAT_BLOCK_EXT"),
1655 Self::ASTC_6X6X5_UNORM_BLOCK_EXT => Some("ASTC_6X6X5_UNORM_BLOCK_EXT"),
1656 Self::ASTC_6X6X5_SRGB_BLOCK_EXT => Some("ASTC_6X6X5_SRGB_BLOCK_EXT"),
1657 Self::ASTC_6X6X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X5_SFLOAT_BLOCK_EXT"),
1658 Self::ASTC_6X6X6_UNORM_BLOCK_EXT => Some("ASTC_6X6X6_UNORM_BLOCK_EXT"),
1659 Self::ASTC_6X6X6_SRGB_BLOCK_EXT => Some("ASTC_6X6X6_SRGB_BLOCK_EXT"),
1660 Self::ASTC_6X6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X6_SFLOAT_BLOCK_EXT"),
1661 Self::A4R4G4B4_UNORM_PACK16_EXT => Some("A4R4G4B4_UNORM_PACK16_EXT"),
1662 Self::A4B4G4R4_UNORM_PACK16_EXT => Some("A4B4G4R4_UNORM_PACK16_EXT"),
1663 Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"),
1664 Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"),
1665 Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"),
1666 Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"),
1667 Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"),
1668 Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"),
1669 Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"),
1670 Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"),
1671 Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"),
1672 Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"),
1673 Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => {
1674 Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16")
1675 }
1676 Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => {
1677 Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16")
1678 }
1679 Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => {
1680 Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16")
1681 }
1682 Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => {
1683 Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16")
1684 }
1685 Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => {
1686 Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16")
1687 }
1688 Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => {
1689 Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16")
1690 }
1691 Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => {
1692 Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16")
1693 }
1694 Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"),
1695 Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"),
1696 Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"),
1697 Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => {
1698 Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16")
1699 }
1700 Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => {
1701 Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16")
1702 }
1703 Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => {
1704 Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16")
1705 }
1706 Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => {
1707 Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16")
1708 }
1709 Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => {
1710 Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16")
1711 }
1712 Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => {
1713 Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16")
1714 }
1715 Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => {
1716 Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16")
1717 }
1718 Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"),
1719 Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"),
1720 Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"),
1721 Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"),
1722 Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"),
1723 Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"),
1724 Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"),
1725 _ => None,
1726 };
1727 if let Some(x) = name {
1728 f.write_str(x)
1729 } else {
1730 self.0.fmt(f)
1731 }
1732 }
1733 }
1734 impl fmt::Debug for FormatFeatureFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1735 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1736 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 :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG") , (FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR") , (FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR") , (FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR") , (FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR") , (FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_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")] ;
1737 debug_flags(f, KNOWN, self.0)
1738 }
1739 }
1740 impl fmt::Debug for FragmentShadingRateCombinerOpKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1741 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1742 let name = match *self {
1743 Self::KEEP => Some("KEEP"),
1744 Self::REPLACE => Some("REPLACE"),
1745 Self::MIN => Some("MIN"),
1746 Self::MAX => Some("MAX"),
1747 Self::MUL => Some("MUL"),
1748 _ => None,
1749 };
1750 if let Some(x) = name {
1751 f.write_str(x)
1752 } else {
1753 self.0.fmt(f)
1754 }
1755 }
1756 }
1757 impl fmt::Debug for FragmentShadingRateNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1758 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1759 let name = match *self {
1760 Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"),
1761 Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"),
1762 Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"),
1763 Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"),
1764 Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"),
1765 Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"),
1766 Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"),
1767 Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"),
1768 Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"),
1769 Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"),
1770 Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"),
1771 Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"),
1772 _ => None,
1773 };
1774 if let Some(x) = name {
1775 f.write_str(x)
1776 } else {
1777 self.0.fmt(f)
1778 }
1779 }
1780 }
1781 impl fmt::Debug for FragmentShadingRateTypeNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1782 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1783 let name = match *self {
1784 Self::FRAGMENT_SIZE => Some("FRAGMENT_SIZE"),
1785 Self::ENUMS => Some("ENUMS"),
1786 _ => None,
1787 };
1788 if let Some(x) = name {
1789 f.write_str(x)
1790 } else {
1791 self.0.fmt(f)
1792 }
1793 }
1794 }
1795 impl fmt::Debug for FramebufferCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1796 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1797 const KNOWN: &[(Flags, &str)] = &[(FramebufferCreateFlags::IMAGELESS.0, "IMAGELESS")];
1798 debug_flags(f, KNOWN, self.0)
1799 }
1800 }
1801 impl fmt::Debug for FrontFace {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1802 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1803 let name = match *self {
1804 Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"),
1805 Self::CLOCKWISE => Some("CLOCKWISE"),
1806 _ => None,
1807 };
1808 if let Some(x) = name {
1809 f.write_str(x)
1810 } else {
1811 self.0.fmt(f)
1812 }
1813 }
1814 }
1815 impl fmt::Debug for FullScreenExclusiveEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1816 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1817 let name = match *self {
1818 Self::DEFAULT => Some("DEFAULT"),
1819 Self::ALLOWED => Some("ALLOWED"),
1820 Self::DISALLOWED => Some("DISALLOWED"),
1821 Self::APPLICATION_CONTROLLED => Some("APPLICATION_CONTROLLED"),
1822 _ => None,
1823 };
1824 if let Some(x) = name {
1825 f.write_str(x)
1826 } else {
1827 self.0.fmt(f)
1828 }
1829 }
1830 }
1831 impl fmt::Debug for GeometryFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1832 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1833 const KNOWN: &[(Flags, &str)] = &[
1834 (GeometryFlagsKHR::OPAQUE.0, "OPAQUE"),
1835 (
1836 GeometryFlagsKHR::NO_DUPLICATE_ANY_HIT_INVOCATION.0,
1837 "NO_DUPLICATE_ANY_HIT_INVOCATION",
1838 ),
1839 ];
1840 debug_flags(f, KNOWN, self.0)
1841 }
1842 }
1843 impl fmt::Debug for GeometryInstanceFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1844 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1845 const KNOWN: &[(Flags, &str)] = &[
1846 (
1847 GeometryInstanceFlagsKHR::TRIANGLE_FACING_CULL_DISABLE.0,
1848 "TRIANGLE_FACING_CULL_DISABLE",
1849 ),
1850 (
1851 GeometryInstanceFlagsKHR::TRIANGLE_FRONT_COUNTERCLOCKWISE.0,
1852 "TRIANGLE_FRONT_COUNTERCLOCKWISE",
1853 ),
1854 (GeometryInstanceFlagsKHR::FORCE_OPAQUE.0, "FORCE_OPAQUE"),
1855 (
1856 GeometryInstanceFlagsKHR::FORCE_NO_OPAQUE.0,
1857 "FORCE_NO_OPAQUE",
1858 ),
1859 ];
1860 debug_flags(f, KNOWN, self.0)
1861 }
1862 }
1863 impl fmt::Debug for GeometryTypeKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1864 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1865 let name = match *self {
1866 Self::TRIANGLES => Some("TRIANGLES"),
1867 Self::AABBS => Some("AABBS"),
1868 Self::INSTANCES => Some("INSTANCES"),
1869 _ => None,
1870 };
1871 if let Some(x) = name {
1872 f.write_str(x)
1873 } else {
1874 self.0.fmt(f)
1875 }
1876 }
1877 }
1878 impl fmt::Debug for HeadlessSurfaceCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1879 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1880 const KNOWN: &[(Flags, &str)] = &[];
1881 debug_flags(f, KNOWN, self.0)
1882 }
1883 }
1884 impl fmt::Debug for IOSSurfaceCreateFlagsMVK {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1885 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1886 const KNOWN: &[(Flags, &str)] = &[];
1887 debug_flags(f, KNOWN, self.0)
1888 }
1889 }
1890 impl fmt::Debug for ImageAspectFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1891 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1892 const KNOWN: &[(Flags, &str)] = &[
1893 (ImageAspectFlags::COLOR.0, "COLOR"),
1894 (ImageAspectFlags::DEPTH.0, "DEPTH"),
1895 (ImageAspectFlags::STENCIL.0, "STENCIL"),
1896 (ImageAspectFlags::METADATA.0, "METADATA"),
1897 (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"),
1898 (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"),
1899 (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"),
1900 (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"),
1901 (ImageAspectFlags::PLANE_0.0, "PLANE_0"),
1902 (ImageAspectFlags::PLANE_1.0, "PLANE_1"),
1903 (ImageAspectFlags::PLANE_2.0, "PLANE_2"),
1904 ];
1905 debug_flags(f, KNOWN, self.0)
1906 }
1907 }
1908 impl fmt::Debug for ImageCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1909 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1910 const KNOWN: &[(Flags, &str)] = &[
1911 (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"),
1912 (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"),
1913 (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"),
1914 (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"),
1915 (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"),
1916 (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"),
1917 (
1918 ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0,
1919 "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT",
1920 ),
1921 (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"),
1922 (ImageCreateFlags::RESERVED_15_NV.0, "RESERVED_15_NV"),
1923 (ImageCreateFlags::ALIAS.0, "ALIAS"),
1924 (
1925 ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0,
1926 "SPLIT_INSTANCE_BIND_REGIONS",
1927 ),
1928 (
1929 ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0,
1930 "TYPE_2D_ARRAY_COMPATIBLE",
1931 ),
1932 (
1933 ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0,
1934 "BLOCK_TEXEL_VIEW_COMPATIBLE",
1935 ),
1936 (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"),
1937 (ImageCreateFlags::PROTECTED.0, "PROTECTED"),
1938 (ImageCreateFlags::DISJOINT.0, "DISJOINT"),
1939 ];
1940 debug_flags(f, KNOWN, self.0)
1941 }
1942 }
1943 impl fmt::Debug for ImageLayout {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1944 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1945 let name = match *self {
1946 Self::UNDEFINED => Some("UNDEFINED"),
1947 Self::GENERAL => Some("GENERAL"),
1948 Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"),
1949 Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"),
1950 Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"),
1951 Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"),
1952 Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"),
1953 Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"),
1954 Self::PREINITIALIZED => Some("PREINITIALIZED"),
1955 Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"),
1956 Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"),
1957 Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"),
1958 Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"),
1959 Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => {
1960 Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL")
1961 }
1962 Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => {
1963 Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL")
1964 }
1965 Self::DEPTH_ATTACHMENT_OPTIMAL => Some("DEPTH_ATTACHMENT_OPTIMAL"),
1966 Self::DEPTH_READ_ONLY_OPTIMAL => Some("DEPTH_READ_ONLY_OPTIMAL"),
1967 Self::STENCIL_ATTACHMENT_OPTIMAL => Some("STENCIL_ATTACHMENT_OPTIMAL"),
1968 Self::STENCIL_READ_ONLY_OPTIMAL => Some("STENCIL_READ_ONLY_OPTIMAL"),
1969 _ => None,
1970 };
1971 if let Some(x) = name {
1972 f.write_str(x)
1973 } else {
1974 self.0.fmt(f)
1975 }
1976 }
1977 }
1978 impl fmt::Debug for ImagePipeSurfaceCreateFlagsFUCHSIA {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1979 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1980 const KNOWN: &[(Flags, &str)] = &[];
1981 debug_flags(f, KNOWN, self.0)
1982 }
1983 }
1984 impl fmt::Debug for ImageTiling {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1985 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1986 let name = match *self {
1987 Self::OPTIMAL => Some("OPTIMAL"),
1988 Self::LINEAR => Some("LINEAR"),
1989 Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"),
1990 _ => None,
1991 };
1992 if let Some(x) = name {
1993 f.write_str(x)
1994 } else {
1995 self.0.fmt(f)
1996 }
1997 }
1998 }
1999 impl fmt::Debug for ImageType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2000 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2001 let name = match *self {
2002 Self::TYPE_1D => Some("TYPE_1D"),
2003 Self::TYPE_2D => Some("TYPE_2D"),
2004 Self::TYPE_3D => Some("TYPE_3D"),
2005 _ => None,
2006 };
2007 if let Some(x) = name {
2008 f.write_str(x)
2009 } else {
2010 self.0.fmt(f)
2011 }
2012 }
2013 }
2014 impl fmt::Debug for ImageUsageFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2015 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2016 const KNOWN: &[(Flags, &str)] = &[
2017 (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"),
2018 (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"),
2019 (ImageUsageFlags::SAMPLED.0, "SAMPLED"),
2020 (ImageUsageFlags::STORAGE.0, "STORAGE"),
2021 (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"),
2022 (
2023 ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0,
2024 "DEPTH_STENCIL_ATTACHMENT",
2025 ),
2026 (
2027 ImageUsageFlags::TRANSIENT_ATTACHMENT.0,
2028 "TRANSIENT_ATTACHMENT",
2029 ),
2030 (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"),
2031 (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"),
2032 (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"),
2033 (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"),
2034 (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"),
2035 (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"),
2036 (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"),
2037 (
2038 ImageUsageFlags::SHADING_RATE_IMAGE_NV.0,
2039 "SHADING_RATE_IMAGE_NV",
2040 ),
2041 (ImageUsageFlags::RESERVED_16_QCOM.0, "RESERVED_16_QCOM"),
2042 (ImageUsageFlags::RESERVED_17_QCOM.0, "RESERVED_17_QCOM"),
2043 (
2044 ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0,
2045 "FRAGMENT_DENSITY_MAP_EXT",
2046 ),
2047 ];
2048 debug_flags(f, KNOWN, self.0)
2049 }
2050 }
2051 impl fmt::Debug for ImageViewCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2052 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2053 const KNOWN: &[(Flags, &str)] = &[
2054 (
2055 ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0,
2056 "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT",
2057 ),
2058 (
2059 ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0,
2060 "FRAGMENT_DENSITY_MAP_DEFERRED_EXT",
2061 ),
2062 ];
2063 debug_flags(f, KNOWN, self.0)
2064 }
2065 }
2066 impl fmt::Debug for ImageViewType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2067 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2068 let name = match *self {
2069 Self::TYPE_1D => Some("TYPE_1D"),
2070 Self::TYPE_2D => Some("TYPE_2D"),
2071 Self::TYPE_3D => Some("TYPE_3D"),
2072 Self::CUBE => Some("CUBE"),
2073 Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"),
2074 Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"),
2075 Self::CUBE_ARRAY => Some("CUBE_ARRAY"),
2076 _ => None,
2077 };
2078 if let Some(x) = name {
2079 f.write_str(x)
2080 } else {
2081 self.0.fmt(f)
2082 }
2083 }
2084 }
2085 impl fmt::Debug for IndexType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2086 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2087 let name = match *self {
2088 Self::UINT16 => Some("UINT16"),
2089 Self::UINT32 => Some("UINT32"),
2090 Self::NONE_KHR => Some("NONE_KHR"),
2091 Self::UINT8_EXT => Some("UINT8_EXT"),
2092 _ => None,
2093 };
2094 if let Some(x) = name {
2095 f.write_str(x)
2096 } else {
2097 self.0.fmt(f)
2098 }
2099 }
2100 }
2101 impl fmt::Debug for IndirectCommandsLayoutUsageFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2102 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2103 const KNOWN: &[(Flags, &str)] = &[
2104 (
2105 IndirectCommandsLayoutUsageFlagsNV::EXPLICIT_PREPROCESS.0,
2106 "EXPLICIT_PREPROCESS",
2107 ),
2108 (
2109 IndirectCommandsLayoutUsageFlagsNV::INDEXED_SEQUENCES.0,
2110 "INDEXED_SEQUENCES",
2111 ),
2112 (
2113 IndirectCommandsLayoutUsageFlagsNV::UNORDERED_SEQUENCES.0,
2114 "UNORDERED_SEQUENCES",
2115 ),
2116 ];
2117 debug_flags(f, KNOWN, self.0)
2118 }
2119 }
2120 impl fmt::Debug for IndirectCommandsTokenTypeNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2121 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2122 let name = match *self {
2123 Self::SHADER_GROUP => Some("SHADER_GROUP"),
2124 Self::STATE_FLAGS => Some("STATE_FLAGS"),
2125 Self::INDEX_BUFFER => Some("INDEX_BUFFER"),
2126 Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"),
2127 Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"),
2128 Self::DRAW_INDEXED => Some("DRAW_INDEXED"),
2129 Self::DRAW => Some("DRAW"),
2130 Self::DRAW_TASKS => Some("DRAW_TASKS"),
2131 _ => None,
2132 };
2133 if let Some(x) = name {
2134 f.write_str(x)
2135 } else {
2136 self.0.fmt(f)
2137 }
2138 }
2139 }
2140 impl fmt::Debug for IndirectStateFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2141 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2142 const KNOWN: &[(Flags, &str)] =
2143 &[(IndirectStateFlagsNV::FLAG_FRONTFACE.0, "FLAG_FRONTFACE")];
2144 debug_flags(f, KNOWN, self.0)
2145 }
2146 }
2147 impl fmt::Debug for InstanceCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2148 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2149 const KNOWN: &[(Flags, &str)] = &[];
2150 debug_flags(f, KNOWN, self.0)
2151 }
2152 }
2153 impl fmt::Debug for InternalAllocationType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2154 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2155 let name = match *self {
2156 Self::EXECUTABLE => Some("EXECUTABLE"),
2157 _ => None,
2158 };
2159 if let Some(x) = name {
2160 f.write_str(x)
2161 } else {
2162 self.0.fmt(f)
2163 }
2164 }
2165 }
2166 impl fmt::Debug for LineRasterizationModeEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2167 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2168 let name = match *self {
2169 Self::DEFAULT => Some("DEFAULT"),
2170 Self::RECTANGULAR => Some("RECTANGULAR"),
2171 Self::BRESENHAM => Some("BRESENHAM"),
2172 Self::RECTANGULAR_SMOOTH => Some("RECTANGULAR_SMOOTH"),
2173 _ => None,
2174 };
2175 if let Some(x) = name {
2176 f.write_str(x)
2177 } else {
2178 self.0.fmt(f)
2179 }
2180 }
2181 }
2182 impl fmt::Debug for LogicOp {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2183 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2184 let name = match *self {
2185 Self::CLEAR => Some("CLEAR"),
2186 Self::AND => Some("AND"),
2187 Self::AND_REVERSE => Some("AND_REVERSE"),
2188 Self::COPY => Some("COPY"),
2189 Self::AND_INVERTED => Some("AND_INVERTED"),
2190 Self::NO_OP => Some("NO_OP"),
2191 Self::XOR => Some("XOR"),
2192 Self::OR => Some("OR"),
2193 Self::NOR => Some("NOR"),
2194 Self::EQUIVALENT => Some("EQUIVALENT"),
2195 Self::INVERT => Some("INVERT"),
2196 Self::OR_REVERSE => Some("OR_REVERSE"),
2197 Self::COPY_INVERTED => Some("COPY_INVERTED"),
2198 Self::OR_INVERTED => Some("OR_INVERTED"),
2199 Self::NAND => Some("NAND"),
2200 Self::SET => Some("SET"),
2201 _ => None,
2202 };
2203 if let Some(x) = name {
2204 f.write_str(x)
2205 } else {
2206 self.0.fmt(f)
2207 }
2208 }
2209 }
2210 impl fmt::Debug for MacOSSurfaceCreateFlagsMVK {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2211 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2212 const KNOWN: &[(Flags, &str)] = &[];
2213 debug_flags(f, KNOWN, self.0)
2214 }
2215 }
2216 impl fmt::Debug for MemoryAllocateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2217 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2218 const KNOWN: &[(Flags, &str)] = &[
2219 (MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK"),
2220 (MemoryAllocateFlags::DEVICE_ADDRESS.0, "DEVICE_ADDRESS"),
2221 (
2222 MemoryAllocateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
2223 "DEVICE_ADDRESS_CAPTURE_REPLAY",
2224 ),
2225 ];
2226 debug_flags(f, KNOWN, self.0)
2227 }
2228 }
2229 impl fmt::Debug for MemoryHeapFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2230 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2231 const KNOWN: &[(Flags, &str)] = &[
2232 (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"),
2233 (MemoryHeapFlags::RESERVED_2_KHR.0, "RESERVED_2_KHR"),
2234 (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"),
2235 ];
2236 debug_flags(f, KNOWN, self.0)
2237 }
2238 }
2239 impl fmt::Debug for MemoryMapFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2240 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2241 const KNOWN: &[(Flags, &str)] = &[];
2242 debug_flags(f, KNOWN, self.0)
2243 }
2244 }
2245 impl fmt::Debug for MemoryOverallocationBehaviorAMD {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2246 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2247 let name = match *self {
2248 Self::DEFAULT => Some("DEFAULT"),
2249 Self::ALLOWED => Some("ALLOWED"),
2250 Self::DISALLOWED => Some("DISALLOWED"),
2251 _ => None,
2252 };
2253 if let Some(x) = name {
2254 f.write_str(x)
2255 } else {
2256 self.0.fmt(f)
2257 }
2258 }
2259 }
2260 impl fmt::Debug for MemoryPropertyFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2261 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2262 const KNOWN: &[(Flags, &str)] = &[
2263 (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"),
2264 (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"),
2265 (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"),
2266 (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"),
2267 (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"),
2268 (
2269 MemoryPropertyFlags::DEVICE_COHERENT_AMD.0,
2270 "DEVICE_COHERENT_AMD",
2271 ),
2272 (
2273 MemoryPropertyFlags::DEVICE_UNCACHED_AMD.0,
2274 "DEVICE_UNCACHED_AMD",
2275 ),
2276 (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"),
2277 ];
2278 debug_flags(f, KNOWN, self.0)
2279 }
2280 }
2281 impl fmt::Debug for MetalSurfaceCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2282 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2283 const KNOWN: &[(Flags, &str)] = &[];
2284 debug_flags(f, KNOWN, self.0)
2285 }
2286 }
2287 impl fmt::Debug for ObjectType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2288 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2289 let name = match *self {
2290 Self::UNKNOWN => Some("UNKNOWN"),
2291 Self::INSTANCE => Some("INSTANCE"),
2292 Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"),
2293 Self::DEVICE => Some("DEVICE"),
2294 Self::QUEUE => Some("QUEUE"),
2295 Self::SEMAPHORE => Some("SEMAPHORE"),
2296 Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"),
2297 Self::FENCE => Some("FENCE"),
2298 Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"),
2299 Self::BUFFER => Some("BUFFER"),
2300 Self::IMAGE => Some("IMAGE"),
2301 Self::EVENT => Some("EVENT"),
2302 Self::QUERY_POOL => Some("QUERY_POOL"),
2303 Self::BUFFER_VIEW => Some("BUFFER_VIEW"),
2304 Self::IMAGE_VIEW => Some("IMAGE_VIEW"),
2305 Self::SHADER_MODULE => Some("SHADER_MODULE"),
2306 Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"),
2307 Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"),
2308 Self::RENDER_PASS => Some("RENDER_PASS"),
2309 Self::PIPELINE => Some("PIPELINE"),
2310 Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"),
2311 Self::SAMPLER => Some("SAMPLER"),
2312 Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"),
2313 Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"),
2314 Self::FRAMEBUFFER => Some("FRAMEBUFFER"),
2315 Self::COMMAND_POOL => Some("COMMAND_POOL"),
2316 Self::SURFACE_KHR => Some("SURFACE_KHR"),
2317 Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"),
2318 Self::DISPLAY_KHR => Some("DISPLAY_KHR"),
2319 Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"),
2320 Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"),
2321 Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"),
2322 Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
2323 Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"),
2324 Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
2325 Self::PERFORMANCE_CONFIGURATION_INTEL => Some("PERFORMANCE_CONFIGURATION_INTEL"),
2326 Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"),
2327 Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"),
2328 Self::PRIVATE_DATA_SLOT_EXT => Some("PRIVATE_DATA_SLOT_EXT"),
2329 Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"),
2330 Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"),
2331 _ => None,
2332 };
2333 if let Some(x) = name {
2334 f.write_str(x)
2335 } else {
2336 self.0.fmt(f)
2337 }
2338 }
2339 }
2340 impl fmt::Debug for PeerMemoryFeatureFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2341 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2342 const KNOWN: &[(Flags, &str)] = &[
2343 (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"),
2344 (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"),
2345 (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"),
2346 (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"),
2347 ];
2348 debug_flags(f, KNOWN, self.0)
2349 }
2350 }
2351 impl fmt::Debug for PerformanceConfigurationTypeINTEL {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2352 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2353 let name = match * self { Self :: PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL => Some ("PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL") , _ => None , } ;
2354 if let Some(x) = name {
2355 f.write_str(x)
2356 } else {
2357 self.0.fmt(f)
2358 }
2359 }
2360 }
2361 impl fmt::Debug for PerformanceCounterDescriptionFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2362 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2363 const KNOWN: &[(Flags, &str)] = &[
2364 (
2365 PerformanceCounterDescriptionFlagsKHR::PERFORMANCE_IMPACTING.0,
2366 "PERFORMANCE_IMPACTING",
2367 ),
2368 (
2369 PerformanceCounterDescriptionFlagsKHR::CONCURRENTLY_IMPACTED.0,
2370 "CONCURRENTLY_IMPACTED",
2371 ),
2372 ];
2373 debug_flags(f, KNOWN, self.0)
2374 }
2375 }
2376 impl fmt::Debug for PerformanceCounterScopeKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2377 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2378 let name = match *self {
2379 Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"),
2380 Self::RENDER_PASS => Some("RENDER_PASS"),
2381 Self::COMMAND => Some("COMMAND"),
2382 _ => None,
2383 };
2384 if let Some(x) = name {
2385 f.write_str(x)
2386 } else {
2387 self.0.fmt(f)
2388 }
2389 }
2390 }
2391 impl fmt::Debug for PerformanceCounterStorageKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2392 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2393 let name = match *self {
2394 Self::INT32 => Some("INT32"),
2395 Self::INT64 => Some("INT64"),
2396 Self::UINT32 => Some("UINT32"),
2397 Self::UINT64 => Some("UINT64"),
2398 Self::FLOAT32 => Some("FLOAT32"),
2399 Self::FLOAT64 => Some("FLOAT64"),
2400 _ => None,
2401 };
2402 if let Some(x) = name {
2403 f.write_str(x)
2404 } else {
2405 self.0.fmt(f)
2406 }
2407 }
2408 }
2409 impl fmt::Debug for PerformanceCounterUnitKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2410 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2411 let name = match *self {
2412 Self::GENERIC => Some("GENERIC"),
2413 Self::PERCENTAGE => Some("PERCENTAGE"),
2414 Self::NANOSECONDS => Some("NANOSECONDS"),
2415 Self::BYTES => Some("BYTES"),
2416 Self::BYTES_PER_SECOND => Some("BYTES_PER_SECOND"),
2417 Self::KELVIN => Some("KELVIN"),
2418 Self::WATTS => Some("WATTS"),
2419 Self::VOLTS => Some("VOLTS"),
2420 Self::AMPS => Some("AMPS"),
2421 Self::HERTZ => Some("HERTZ"),
2422 Self::CYCLES => Some("CYCLES"),
2423 _ => None,
2424 };
2425 if let Some(x) = name {
2426 f.write_str(x)
2427 } else {
2428 self.0.fmt(f)
2429 }
2430 }
2431 }
2432 impl fmt::Debug for PerformanceOverrideTypeINTEL {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2433 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2434 let name = match *self {
2435 Self::PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL => {
2436 Some("PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL")
2437 }
2438 Self::PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL => {
2439 Some("PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL")
2440 }
2441 _ => None,
2442 };
2443 if let Some(x) = name {
2444 f.write_str(x)
2445 } else {
2446 self.0.fmt(f)
2447 }
2448 }
2449 }
2450 impl fmt::Debug for PerformanceParameterTypeINTEL {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2451 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2452 let name = match *self {
2453 Self::PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL => {
2454 Some("PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL")
2455 }
2456 Self::PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALIDS_INTEL => {
2457 Some("PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALIDS_INTEL")
2458 }
2459 _ => None,
2460 };
2461 if let Some(x) = name {
2462 f.write_str(x)
2463 } else {
2464 self.0.fmt(f)
2465 }
2466 }
2467 }
2468 impl fmt::Debug for PerformanceValueTypeINTEL {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2469 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2470 let name = match *self {
2471 Self::PERFORMANCE_VALUE_TYPE_UINT32_INTEL => {
2472 Some("PERFORMANCE_VALUE_TYPE_UINT32_INTEL")
2473 }
2474 Self::PERFORMANCE_VALUE_TYPE_UINT64_INTEL => {
2475 Some("PERFORMANCE_VALUE_TYPE_UINT64_INTEL")
2476 }
2477 Self::PERFORMANCE_VALUE_TYPE_FLOAT_INTEL => Some("PERFORMANCE_VALUE_TYPE_FLOAT_INTEL"),
2478 Self::PERFORMANCE_VALUE_TYPE_BOOL_INTEL => Some("PERFORMANCE_VALUE_TYPE_BOOL_INTEL"),
2479 Self::PERFORMANCE_VALUE_TYPE_STRING_INTEL => {
2480 Some("PERFORMANCE_VALUE_TYPE_STRING_INTEL")
2481 }
2482 _ => None,
2483 };
2484 if let Some(x) = name {
2485 f.write_str(x)
2486 } else {
2487 self.0.fmt(f)
2488 }
2489 }
2490 }
2491 impl fmt::Debug for PhysicalDeviceType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2492 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2493 let name = match *self {
2494 Self::OTHER => Some("OTHER"),
2495 Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"),
2496 Self::DISCRETE_GPU => Some("DISCRETE_GPU"),
2497 Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"),
2498 Self::CPU => Some("CPU"),
2499 _ => None,
2500 };
2501 if let Some(x) = name {
2502 f.write_str(x)
2503 } else {
2504 self.0.fmt(f)
2505 }
2506 }
2507 }
2508 impl fmt::Debug for PipelineBindPoint {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2509 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2510 let name = match *self {
2511 Self::GRAPHICS => Some("GRAPHICS"),
2512 Self::COMPUTE => Some("COMPUTE"),
2513 Self::RAY_TRACING_KHR => Some("RAY_TRACING_KHR"),
2514 _ => None,
2515 };
2516 if let Some(x) = name {
2517 f.write_str(x)
2518 } else {
2519 self.0.fmt(f)
2520 }
2521 }
2522 }
2523 impl fmt::Debug for PipelineCacheCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2524 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2525 const KNOWN: &[(Flags, &str)] = &[
2526 (PipelineCacheCreateFlags::RESERVED_1_EXT.0, "RESERVED_1_EXT"),
2527 (
2528 PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED_EXT.0,
2529 "EXTERNALLY_SYNCHRONIZED_EXT",
2530 ),
2531 (PipelineCacheCreateFlags::RESERVED_2_EXT.0, "RESERVED_2_EXT"),
2532 ];
2533 debug_flags(f, KNOWN, self.0)
2534 }
2535 }
2536 impl fmt::Debug for PipelineCacheHeaderVersion {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2537 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2538 let name = match *self {
2539 Self::ONE => Some("ONE"),
2540 _ => None,
2541 };
2542 if let Some(x) = name {
2543 f.write_str(x)
2544 } else {
2545 self.0.fmt(f)
2546 }
2547 }
2548 }
2549 impl fmt::Debug for PipelineColorBlendStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2550 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2551 const KNOWN: &[(Flags, &str)] = &[];
2552 debug_flags(f, KNOWN, self.0)
2553 }
2554 }
2555 impl fmt::Debug for PipelineCompilerControlFlagsAMD {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2556 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2557 const KNOWN: &[(Flags, &str)] = &[];
2558 debug_flags(f, KNOWN, self.0)
2559 }
2560 }
2561 impl fmt::Debug for PipelineCoverageModulationStateCreateFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2562 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2563 const KNOWN: &[(Flags, &str)] = &[];
2564 debug_flags(f, KNOWN, self.0)
2565 }
2566 }
2567 impl fmt::Debug for PipelineCoverageReductionStateCreateFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2568 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2569 const KNOWN: &[(Flags, &str)] = &[];
2570 debug_flags(f, KNOWN, self.0)
2571 }
2572 }
2573 impl fmt::Debug for PipelineCoverageToColorStateCreateFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2574 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2575 const KNOWN: &[(Flags, &str)] = &[];
2576 debug_flags(f, KNOWN, self.0)
2577 }
2578 }
2579 impl fmt::Debug for PipelineCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2580 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2581 const KNOWN: &[(Flags, &str)] = &[
2582 (
2583 PipelineCreateFlags::DISABLE_OPTIMIZATION.0,
2584 "DISABLE_OPTIMIZATION",
2585 ),
2586 (
2587 PipelineCreateFlags::ALLOW_DERIVATIVES.0,
2588 "ALLOW_DERIVATIVES",
2589 ),
2590 (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"),
2591 (
2592 PipelineCreateFlags::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0,
2593 "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR",
2594 ),
2595 (
2596 PipelineCreateFlags::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR.0,
2597 "RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR",
2598 ),
2599 (
2600 PipelineCreateFlags::RAY_TRACING_NO_NULL_MISS_SHADERS_KHR.0,
2601 "RAY_TRACING_NO_NULL_MISS_SHADERS_KHR",
2602 ),
2603 (
2604 PipelineCreateFlags::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR.0,
2605 "RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR",
2606 ),
2607 (
2608 PipelineCreateFlags::RAY_TRACING_SKIP_TRIANGLES_KHR.0,
2609 "RAY_TRACING_SKIP_TRIANGLES_KHR",
2610 ),
2611 (
2612 PipelineCreateFlags::RAY_TRACING_SKIP_AABBS_KHR.0,
2613 "RAY_TRACING_SKIP_AABBS_KHR",
2614 ),
2615 (
2616 PipelineCreateFlags::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR.0,
2617 "RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR",
2618 ),
2619 (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"),
2620 (
2621 PipelineCreateFlags::CAPTURE_STATISTICS_KHR.0,
2622 "CAPTURE_STATISTICS_KHR",
2623 ),
2624 (
2625 PipelineCreateFlags::CAPTURE_INTERNAL_REPRESENTATIONS_KHR.0,
2626 "CAPTURE_INTERNAL_REPRESENTATIONS_KHR",
2627 ),
2628 (
2629 PipelineCreateFlags::INDIRECT_BINDABLE_NV.0,
2630 "INDIRECT_BINDABLE_NV",
2631 ),
2632 (PipelineCreateFlags::LIBRARY_KHR.0, "LIBRARY_KHR"),
2633 (
2634 PipelineCreateFlags::FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT.0,
2635 "FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT",
2636 ),
2637 (
2638 PipelineCreateFlags::EARLY_RETURN_ON_FAILURE_EXT.0,
2639 "EARLY_RETURN_ON_FAILURE_EXT",
2640 ),
2641 (
2642 PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0,
2643 "VIEW_INDEX_FROM_DEVICE_INDEX",
2644 ),
2645 (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"),
2646 ];
2647 debug_flags(f, KNOWN, self.0)
2648 }
2649 }
2650 impl fmt::Debug for PipelineCreationFeedbackFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2651 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2652 const KNOWN: &[(Flags, &str)] = &[
2653 (PipelineCreationFeedbackFlagsEXT::VALID.0, "VALID"),
2654 (
2655 PipelineCreationFeedbackFlagsEXT::APPLICATION_PIPELINE_CACHE_HIT.0,
2656 "APPLICATION_PIPELINE_CACHE_HIT",
2657 ),
2658 (
2659 PipelineCreationFeedbackFlagsEXT::BASE_PIPELINE_ACCELERATION.0,
2660 "BASE_PIPELINE_ACCELERATION",
2661 ),
2662 ];
2663 debug_flags(f, KNOWN, self.0)
2664 }
2665 }
2666 impl fmt::Debug for PipelineDepthStencilStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2667 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2668 const KNOWN: &[(Flags, &str)] = &[];
2669 debug_flags(f, KNOWN, self.0)
2670 }
2671 }
2672 impl fmt::Debug for PipelineDiscardRectangleStateCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2673 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2674 const KNOWN: &[(Flags, &str)] = &[];
2675 debug_flags(f, KNOWN, self.0)
2676 }
2677 }
2678 impl fmt::Debug for PipelineDynamicStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2679 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2680 const KNOWN: &[(Flags, &str)] = &[];
2681 debug_flags(f, KNOWN, self.0)
2682 }
2683 }
2684 impl fmt::Debug for PipelineExecutableStatisticFormatKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2685 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2686 let name = match *self {
2687 Self::BOOL32 => Some("BOOL32"),
2688 Self::INT64 => Some("INT64"),
2689 Self::UINT64 => Some("UINT64"),
2690 Self::FLOAT64 => Some("FLOAT64"),
2691 _ => None,
2692 };
2693 if let Some(x) = name {
2694 f.write_str(x)
2695 } else {
2696 self.0.fmt(f)
2697 }
2698 }
2699 }
2700 impl fmt::Debug for PipelineInputAssemblyStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2701 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2702 const KNOWN: &[(Flags, &str)] = &[];
2703 debug_flags(f, KNOWN, self.0)
2704 }
2705 }
2706 impl fmt::Debug for PipelineLayoutCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2707 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2708 const KNOWN: &[(Flags, &str)] = &[];
2709 debug_flags(f, KNOWN, self.0)
2710 }
2711 }
2712 impl fmt::Debug for PipelineMultisampleStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2713 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2714 const KNOWN: &[(Flags, &str)] = &[];
2715 debug_flags(f, KNOWN, self.0)
2716 }
2717 }
2718 impl fmt::Debug for PipelineRasterizationConservativeStateCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2719 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2720 const KNOWN: &[(Flags, &str)] = &[];
2721 debug_flags(f, KNOWN, self.0)
2722 }
2723 }
2724 impl fmt::Debug for PipelineRasterizationDepthClipStateCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2725 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2726 const KNOWN: &[(Flags, &str)] = &[];
2727 debug_flags(f, KNOWN, self.0)
2728 }
2729 }
2730 impl fmt::Debug for PipelineRasterizationStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2731 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2732 const KNOWN: &[(Flags, &str)] = &[];
2733 debug_flags(f, KNOWN, self.0)
2734 }
2735 }
2736 impl fmt::Debug for PipelineRasterizationStateStreamCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2737 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2738 const KNOWN: &[(Flags, &str)] = &[];
2739 debug_flags(f, KNOWN, self.0)
2740 }
2741 }
2742 impl fmt::Debug for PipelineShaderStageCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2743 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2744 const KNOWN: &[(Flags, &str)] = &[
2745 (
2746 PipelineShaderStageCreateFlags::RESERVED_2_NV.0,
2747 "RESERVED_2_NV",
2748 ),
2749 (
2750 PipelineShaderStageCreateFlags::ALLOW_VARYING_SUBGROUP_SIZE_EXT.0,
2751 "ALLOW_VARYING_SUBGROUP_SIZE_EXT",
2752 ),
2753 (
2754 PipelineShaderStageCreateFlags::REQUIRE_FULL_SUBGROUPS_EXT.0,
2755 "REQUIRE_FULL_SUBGROUPS_EXT",
2756 ),
2757 (
2758 PipelineShaderStageCreateFlags::RESERVED_3_KHR.0,
2759 "RESERVED_3_KHR",
2760 ),
2761 ];
2762 debug_flags(f, KNOWN, self.0)
2763 }
2764 }
2765 impl fmt::Debug for PipelineStageFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2766 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2767 const KNOWN: &[(Flags, &str)] = &[
2768 (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"),
2769 (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"),
2770 (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"),
2771 (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"),
2772 (
2773 PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0,
2774 "TESSELLATION_CONTROL_SHADER",
2775 ),
2776 (
2777 PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0,
2778 "TESSELLATION_EVALUATION_SHADER",
2779 ),
2780 (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"),
2781 (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"),
2782 (
2783 PipelineStageFlags::EARLY_FRAGMENT_TESTS.0,
2784 "EARLY_FRAGMENT_TESTS",
2785 ),
2786 (
2787 PipelineStageFlags::LATE_FRAGMENT_TESTS.0,
2788 "LATE_FRAGMENT_TESTS",
2789 ),
2790 (
2791 PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0,
2792 "COLOR_ATTACHMENT_OUTPUT",
2793 ),
2794 (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"),
2795 (PipelineStageFlags::TRANSFER.0, "TRANSFER"),
2796 (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"),
2797 (PipelineStageFlags::HOST.0, "HOST"),
2798 (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"),
2799 (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"),
2800 (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"),
2801 (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"),
2802 (
2803 PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0,
2804 "TRANSFORM_FEEDBACK_EXT",
2805 ),
2806 (
2807 PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0,
2808 "CONDITIONAL_RENDERING_EXT",
2809 ),
2810 (
2811 PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR.0,
2812 "ACCELERATION_STRUCTURE_BUILD_KHR",
2813 ),
2814 (
2815 PipelineStageFlags::RAY_TRACING_SHADER_KHR.0,
2816 "RAY_TRACING_SHADER_KHR",
2817 ),
2818 (
2819 PipelineStageFlags::SHADING_RATE_IMAGE_NV.0,
2820 "SHADING_RATE_IMAGE_NV",
2821 ),
2822 (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"),
2823 (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"),
2824 (
2825 PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0,
2826 "FRAGMENT_DENSITY_PROCESS_EXT",
2827 ),
2828 (
2829 PipelineStageFlags::COMMAND_PREPROCESS_NV.0,
2830 "COMMAND_PREPROCESS_NV",
2831 ),
2832 ];
2833 debug_flags(f, KNOWN, self.0)
2834 }
2835 }
2836 impl fmt::Debug for PipelineTessellationStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2837 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2838 const KNOWN: &[(Flags, &str)] = &[];
2839 debug_flags(f, KNOWN, self.0)
2840 }
2841 }
2842 impl fmt::Debug for PipelineVertexInputStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2843 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2844 const KNOWN: &[(Flags, &str)] = &[];
2845 debug_flags(f, KNOWN, self.0)
2846 }
2847 }
2848 impl fmt::Debug for PipelineViewportStateCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2849 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2850 const KNOWN: &[(Flags, &str)] = &[];
2851 debug_flags(f, KNOWN, self.0)
2852 }
2853 }
2854 impl fmt::Debug for PipelineViewportSwizzleStateCreateFlagsNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2855 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2856 const KNOWN: &[(Flags, &str)] = &[];
2857 debug_flags(f, KNOWN, self.0)
2858 }
2859 }
2860 impl fmt::Debug for PointClippingBehavior {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2861 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2862 let name = match *self {
2863 Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"),
2864 Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"),
2865 _ => None,
2866 };
2867 if let Some(x) = name {
2868 f.write_str(x)
2869 } else {
2870 self.0.fmt(f)
2871 }
2872 }
2873 }
2874 impl fmt::Debug for PolygonMode {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2875 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2876 let name = match *self {
2877 Self::FILL => Some("FILL"),
2878 Self::LINE => Some("LINE"),
2879 Self::POINT => Some("POINT"),
2880 Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"),
2881 _ => None,
2882 };
2883 if let Some(x) = name {
2884 f.write_str(x)
2885 } else {
2886 self.0.fmt(f)
2887 }
2888 }
2889 }
2890 impl fmt::Debug for PresentModeKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2891 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2892 let name = match *self {
2893 Self::IMMEDIATE => Some("IMMEDIATE"),
2894 Self::MAILBOX => Some("MAILBOX"),
2895 Self::FIFO => Some("FIFO"),
2896 Self::FIFO_RELAXED => Some("FIFO_RELAXED"),
2897 Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"),
2898 Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"),
2899 _ => None,
2900 };
2901 if let Some(x) = name {
2902 f.write_str(x)
2903 } else {
2904 self.0.fmt(f)
2905 }
2906 }
2907 }
2908 impl fmt::Debug for PrimitiveTopology {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2909 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2910 let name = match *self {
2911 Self::POINT_LIST => Some("POINT_LIST"),
2912 Self::LINE_LIST => Some("LINE_LIST"),
2913 Self::LINE_STRIP => Some("LINE_STRIP"),
2914 Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"),
2915 Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"),
2916 Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"),
2917 Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"),
2918 Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"),
2919 Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"),
2920 Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"),
2921 Self::PATCH_LIST => Some("PATCH_LIST"),
2922 _ => None,
2923 };
2924 if let Some(x) = name {
2925 f.write_str(x)
2926 } else {
2927 self.0.fmt(f)
2928 }
2929 }
2930 }
2931 impl fmt::Debug for PrivateDataSlotCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2932 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2933 const KNOWN: &[(Flags, &str)] = &[];
2934 debug_flags(f, KNOWN, self.0)
2935 }
2936 }
2937 impl fmt::Debug for QueryControlFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2938 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2939 const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")];
2940 debug_flags(f, KNOWN, self.0)
2941 }
2942 }
2943 impl fmt::Debug for QueryPipelineStatisticFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2944 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2945 const KNOWN: &[(Flags, &str)] = &[
2946 (
2947 QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0,
2948 "INPUT_ASSEMBLY_VERTICES",
2949 ),
2950 (
2951 QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0,
2952 "INPUT_ASSEMBLY_PRIMITIVES",
2953 ),
2954 (
2955 QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0,
2956 "VERTEX_SHADER_INVOCATIONS",
2957 ),
2958 (
2959 QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0,
2960 "GEOMETRY_SHADER_INVOCATIONS",
2961 ),
2962 (
2963 QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0,
2964 "GEOMETRY_SHADER_PRIMITIVES",
2965 ),
2966 (
2967 QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0,
2968 "CLIPPING_INVOCATIONS",
2969 ),
2970 (
2971 QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0,
2972 "CLIPPING_PRIMITIVES",
2973 ),
2974 (
2975 QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0,
2976 "FRAGMENT_SHADER_INVOCATIONS",
2977 ),
2978 (
2979 QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0,
2980 "TESSELLATION_CONTROL_SHADER_PATCHES",
2981 ),
2982 (
2983 QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0,
2984 "TESSELLATION_EVALUATION_SHADER_INVOCATIONS",
2985 ),
2986 (
2987 QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0,
2988 "COMPUTE_SHADER_INVOCATIONS",
2989 ),
2990 ];
2991 debug_flags(f, KNOWN, self.0)
2992 }
2993 }
2994 impl fmt::Debug for QueryPoolCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2995 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2996 const KNOWN: &[(Flags, &str)] = &[];
2997 debug_flags(f, KNOWN, self.0)
2998 }
2999 }
3000 impl fmt::Debug for QueryPoolSamplingModeINTEL {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3001 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3002 let name = match *self {
3003 Self::QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL => {
3004 Some("QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL")
3005 }
3006 _ => None,
3007 };
3008 if let Some(x) = name {
3009 f.write_str(x)
3010 } else {
3011 self.0.fmt(f)
3012 }
3013 }
3014 }
3015 impl fmt::Debug for QueryResultFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3016 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3017 const KNOWN: &[(Flags, &str)] = &[
3018 (QueryResultFlags::TYPE_64.0, "TYPE_64"),
3019 (QueryResultFlags::WAIT.0, "WAIT"),
3020 (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"),
3021 (QueryResultFlags::PARTIAL.0, "PARTIAL"),
3022 ];
3023 debug_flags(f, KNOWN, self.0)
3024 }
3025 }
3026 impl fmt::Debug for QueryType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3027 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3028 let name = match *self {
3029 Self::OCCLUSION => Some("OCCLUSION"),
3030 Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"),
3031 Self::TIMESTAMP => Some("TIMESTAMP"),
3032 Self::RESERVED_8 => Some("RESERVED_8"),
3033 Self::RESERVED_4 => Some("RESERVED_4"),
3034 Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"),
3035 Self::PERFORMANCE_QUERY_KHR => Some("PERFORMANCE_QUERY_KHR"),
3036 Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR => {
3037 Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR")
3038 }
3039 Self::ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR => {
3040 Some("ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR")
3041 }
3042 Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => {
3043 Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV")
3044 }
3045 Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"),
3046 _ => None,
3047 };
3048 if let Some(x) = name {
3049 f.write_str(x)
3050 } else {
3051 self.0.fmt(f)
3052 }
3053 }
3054 }
3055 impl fmt::Debug for QueueFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3056 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3057 const KNOWN: &[(Flags, &str)] = &[
3058 (QueueFlags::GRAPHICS.0, "GRAPHICS"),
3059 (QueueFlags::COMPUTE.0, "COMPUTE"),
3060 (QueueFlags::TRANSFER.0, "TRANSFER"),
3061 (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"),
3062 (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"),
3063 (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"),
3064 (QueueFlags::PROTECTED.0, "PROTECTED"),
3065 ];
3066 debug_flags(f, KNOWN, self.0)
3067 }
3068 }
3069 impl fmt::Debug for QueueGlobalPriorityEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3070 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3071 let name = match *self {
3072 Self::LOW => Some("LOW"),
3073 Self::MEDIUM => Some("MEDIUM"),
3074 Self::HIGH => Some("HIGH"),
3075 Self::REALTIME => Some("REALTIME"),
3076 _ => None,
3077 };
3078 if let Some(x) = name {
3079 f.write_str(x)
3080 } else {
3081 self.0.fmt(f)
3082 }
3083 }
3084 }
3085 impl fmt::Debug for RasterizationOrderAMD {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3086 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3087 let name = match *self {
3088 Self::STRICT => Some("STRICT"),
3089 Self::RELAXED => Some("RELAXED"),
3090 _ => None,
3091 };
3092 if let Some(x) = name {
3093 f.write_str(x)
3094 } else {
3095 self.0.fmt(f)
3096 }
3097 }
3098 }
3099 impl fmt::Debug for RayTracingShaderGroupTypeKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3100 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3101 let name = match *self {
3102 Self::GENERAL => Some("GENERAL"),
3103 Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"),
3104 Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"),
3105 _ => None,
3106 };
3107 if let Some(x) = name {
3108 f.write_str(x)
3109 } else {
3110 self.0.fmt(f)
3111 }
3112 }
3113 }
3114 impl fmt::Debug for RenderPassCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3115 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3116 const KNOWN: &[(Flags, &str)] = &[
3117 (RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR"),
3118 (RenderPassCreateFlags::TRANSFORM_QCOM.0, "TRANSFORM_QCOM"),
3119 ];
3120 debug_flags(f, KNOWN, self.0)
3121 }
3122 }
3123 impl fmt::Debug for ResolveModeFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3124 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3125 const KNOWN: &[(Flags, &str)] = &[
3126 (ResolveModeFlags::NONE.0, "NONE"),
3127 (ResolveModeFlags::SAMPLE_ZERO.0, "SAMPLE_ZERO"),
3128 (ResolveModeFlags::AVERAGE.0, "AVERAGE"),
3129 (ResolveModeFlags::MIN.0, "MIN"),
3130 (ResolveModeFlags::MAX.0, "MAX"),
3131 ];
3132 debug_flags(f, KNOWN, self.0)
3133 }
3134 }
3135 impl fmt::Debug for Result {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3136 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3137 let name = match *self {
3138 Self::SUCCESS => Some("SUCCESS"),
3139 Self::NOT_READY => Some("NOT_READY"),
3140 Self::TIMEOUT => Some("TIMEOUT"),
3141 Self::EVENT_SET => Some("EVENT_SET"),
3142 Self::EVENT_RESET => Some("EVENT_RESET"),
3143 Self::INCOMPLETE => Some("INCOMPLETE"),
3144 Self::ERROR_OUT_OF_HOST_MEMORY => Some("ERROR_OUT_OF_HOST_MEMORY"),
3145 Self::ERROR_OUT_OF_DEVICE_MEMORY => Some("ERROR_OUT_OF_DEVICE_MEMORY"),
3146 Self::ERROR_INITIALIZATION_FAILED => Some("ERROR_INITIALIZATION_FAILED"),
3147 Self::ERROR_DEVICE_LOST => Some("ERROR_DEVICE_LOST"),
3148 Self::ERROR_MEMORY_MAP_FAILED => Some("ERROR_MEMORY_MAP_FAILED"),
3149 Self::ERROR_LAYER_NOT_PRESENT => Some("ERROR_LAYER_NOT_PRESENT"),
3150 Self::ERROR_EXTENSION_NOT_PRESENT => Some("ERROR_EXTENSION_NOT_PRESENT"),
3151 Self::ERROR_FEATURE_NOT_PRESENT => Some("ERROR_FEATURE_NOT_PRESENT"),
3152 Self::ERROR_INCOMPATIBLE_DRIVER => Some("ERROR_INCOMPATIBLE_DRIVER"),
3153 Self::ERROR_TOO_MANY_OBJECTS => Some("ERROR_TOO_MANY_OBJECTS"),
3154 Self::ERROR_FORMAT_NOT_SUPPORTED => Some("ERROR_FORMAT_NOT_SUPPORTED"),
3155 Self::ERROR_FRAGMENTED_POOL => Some("ERROR_FRAGMENTED_POOL"),
3156 Self::ERROR_UNKNOWN => Some("ERROR_UNKNOWN"),
3157 Self::ERROR_SURFACE_LOST_KHR => Some("ERROR_SURFACE_LOST_KHR"),
3158 Self::ERROR_NATIVE_WINDOW_IN_USE_KHR => Some("ERROR_NATIVE_WINDOW_IN_USE_KHR"),
3159 Self::SUBOPTIMAL_KHR => Some("SUBOPTIMAL_KHR"),
3160 Self::ERROR_OUT_OF_DATE_KHR => Some("ERROR_OUT_OF_DATE_KHR"),
3161 Self::ERROR_INCOMPATIBLE_DISPLAY_KHR => Some("ERROR_INCOMPATIBLE_DISPLAY_KHR"),
3162 Self::ERROR_VALIDATION_FAILED_EXT => Some("ERROR_VALIDATION_FAILED_EXT"),
3163 Self::ERROR_INVALID_SHADER_NV => Some("ERROR_INVALID_SHADER_NV"),
3164 Self::ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT => {
3165 Some("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT")
3166 }
3167 Self::ERROR_NOT_PERMITTED_EXT => Some("ERROR_NOT_PERMITTED_EXT"),
3168 Self::ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT => {
3169 Some("ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT")
3170 }
3171 Self::THREAD_IDLE_KHR => Some("THREAD_IDLE_KHR"),
3172 Self::THREAD_DONE_KHR => Some("THREAD_DONE_KHR"),
3173 Self::OPERATION_DEFERRED_KHR => Some("OPERATION_DEFERRED_KHR"),
3174 Self::OPERATION_NOT_DEFERRED_KHR => Some("OPERATION_NOT_DEFERRED_KHR"),
3175 Self::PIPELINE_COMPILE_REQUIRED_EXT => Some("PIPELINE_COMPILE_REQUIRED_EXT"),
3176 Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"),
3177 Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"),
3178 Self::ERROR_FRAGMENTATION => Some("ERROR_FRAGMENTATION"),
3179 Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS => {
3180 Some("ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS")
3181 }
3182 _ => None,
3183 };
3184 if let Some(x) = name {
3185 f.write_str(x)
3186 } else {
3187 self.0.fmt(f)
3188 }
3189 }
3190 }
3191 impl fmt::Debug for SampleCountFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3192 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3193 const KNOWN: &[(Flags, &str)] = &[
3194 (SampleCountFlags::TYPE_1.0, "TYPE_1"),
3195 (SampleCountFlags::TYPE_2.0, "TYPE_2"),
3196 (SampleCountFlags::TYPE_4.0, "TYPE_4"),
3197 (SampleCountFlags::TYPE_8.0, "TYPE_8"),
3198 (SampleCountFlags::TYPE_16.0, "TYPE_16"),
3199 (SampleCountFlags::TYPE_32.0, "TYPE_32"),
3200 (SampleCountFlags::TYPE_64.0, "TYPE_64"),
3201 ];
3202 debug_flags(f, KNOWN, self.0)
3203 }
3204 }
3205 impl fmt::Debug for SamplerAddressMode {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3206 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3207 let name = match *self {
3208 Self::REPEAT => Some("REPEAT"),
3209 Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"),
3210 Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"),
3211 Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"),
3212 Self::MIRROR_CLAMP_TO_EDGE => Some("MIRROR_CLAMP_TO_EDGE"),
3213 _ => None,
3214 };
3215 if let Some(x) = name {
3216 f.write_str(x)
3217 } else {
3218 self.0.fmt(f)
3219 }
3220 }
3221 }
3222 impl fmt::Debug for SamplerCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3223 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3224 const KNOWN: &[(Flags, &str)] = &[
3225 (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"),
3226 (
3227 SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0,
3228 "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT",
3229 ),
3230 ];
3231 debug_flags(f, KNOWN, self.0)
3232 }
3233 }
3234 impl fmt::Debug for SamplerMipmapMode {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3235 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3236 let name = match *self {
3237 Self::NEAREST => Some("NEAREST"),
3238 Self::LINEAR => Some("LINEAR"),
3239 _ => None,
3240 };
3241 if let Some(x) = name {
3242 f.write_str(x)
3243 } else {
3244 self.0.fmt(f)
3245 }
3246 }
3247 }
3248 impl fmt::Debug for SamplerReductionMode {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3249 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3250 let name = match *self {
3251 Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"),
3252 Self::MIN => Some("MIN"),
3253 Self::MAX => Some("MAX"),
3254 _ => None,
3255 };
3256 if let Some(x) = name {
3257 f.write_str(x)
3258 } else {
3259 self.0.fmt(f)
3260 }
3261 }
3262 }
3263 impl fmt::Debug for SamplerYcbcrModelConversion {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3264 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3265 let name = match *self {
3266 Self::RGB_IDENTITY => Some("RGB_IDENTITY"),
3267 Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"),
3268 Self::YCBCR_709 => Some("YCBCR_709"),
3269 Self::YCBCR_601 => Some("YCBCR_601"),
3270 Self::YCBCR_2020 => Some("YCBCR_2020"),
3271 _ => None,
3272 };
3273 if let Some(x) = name {
3274 f.write_str(x)
3275 } else {
3276 self.0.fmt(f)
3277 }
3278 }
3279 }
3280 impl fmt::Debug for SamplerYcbcrRange {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3281 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3282 let name = match *self {
3283 Self::ITU_FULL => Some("ITU_FULL"),
3284 Self::ITU_NARROW => Some("ITU_NARROW"),
3285 _ => None,
3286 };
3287 if let Some(x) = name {
3288 f.write_str(x)
3289 } else {
3290 self.0.fmt(f)
3291 }
3292 }
3293 }
3294 impl fmt::Debug for ScopeNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3295 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3296 let name = match *self {
3297 Self::DEVICE => Some("DEVICE"),
3298 Self::WORKGROUP => Some("WORKGROUP"),
3299 Self::SUBGROUP => Some("SUBGROUP"),
3300 Self::QUEUE_FAMILY => Some("QUEUE_FAMILY"),
3301 _ => None,
3302 };
3303 if let Some(x) = name {
3304 f.write_str(x)
3305 } else {
3306 self.0.fmt(f)
3307 }
3308 }
3309 }
3310 impl fmt::Debug for SemaphoreCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3311 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3312 const KNOWN: &[(Flags, &str)] = &[];
3313 debug_flags(f, KNOWN, self.0)
3314 }
3315 }
3316 impl fmt::Debug for SemaphoreImportFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3317 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3318 const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")];
3319 debug_flags(f, KNOWN, self.0)
3320 }
3321 }
3322 impl fmt::Debug for SemaphoreType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3323 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3324 let name = match *self {
3325 Self::BINARY => Some("BINARY"),
3326 Self::TIMELINE => Some("TIMELINE"),
3327 _ => None,
3328 };
3329 if let Some(x) = name {
3330 f.write_str(x)
3331 } else {
3332 self.0.fmt(f)
3333 }
3334 }
3335 }
3336 impl fmt::Debug for SemaphoreWaitFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3337 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3338 const KNOWN: &[(Flags, &str)] = &[(SemaphoreWaitFlags::ANY.0, "ANY")];
3339 debug_flags(f, KNOWN, self.0)
3340 }
3341 }
3342 impl fmt::Debug for ShaderCorePropertiesFlagsAMD {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3343 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3344 const KNOWN: &[(Flags, &str)] = &[];
3345 debug_flags(f, KNOWN, self.0)
3346 }
3347 }
3348 impl fmt::Debug for ShaderFloatControlsIndependence {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3349 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3350 let name = match *self {
3351 Self::TYPE_32_ONLY => Some("TYPE_32_ONLY"),
3352 Self::ALL => Some("ALL"),
3353 Self::NONE => Some("NONE"),
3354 _ => None,
3355 };
3356 if let Some(x) = name {
3357 f.write_str(x)
3358 } else {
3359 self.0.fmt(f)
3360 }
3361 }
3362 }
3363 impl fmt::Debug for ShaderGroupShaderKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3364 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3365 let name = match *self {
3366 Self::GENERAL => Some("GENERAL"),
3367 Self::CLOSEST_HIT => Some("CLOSEST_HIT"),
3368 Self::ANY_HIT => Some("ANY_HIT"),
3369 Self::INTERSECTION => Some("INTERSECTION"),
3370 _ => None,
3371 };
3372 if let Some(x) = name {
3373 f.write_str(x)
3374 } else {
3375 self.0.fmt(f)
3376 }
3377 }
3378 }
3379 impl fmt::Debug for ShaderInfoTypeAMD {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3380 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3381 let name = match *self {
3382 Self::STATISTICS => Some("STATISTICS"),
3383 Self::BINARY => Some("BINARY"),
3384 Self::DISASSEMBLY => Some("DISASSEMBLY"),
3385 _ => None,
3386 };
3387 if let Some(x) = name {
3388 f.write_str(x)
3389 } else {
3390 self.0.fmt(f)
3391 }
3392 }
3393 }
3394 impl fmt::Debug for ShaderModuleCreateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3395 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3396 const KNOWN: &[(Flags, &str)] =
3397 &[(ShaderModuleCreateFlags::RESERVED_0_NV.0, "RESERVED_0_NV")];
3398 debug_flags(f, KNOWN, self.0)
3399 }
3400 }
3401 impl fmt::Debug for ShaderStageFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3402 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3403 const KNOWN: &[(Flags, &str)] = &[
3404 (ShaderStageFlags::VERTEX.0, "VERTEX"),
3405 (
3406 ShaderStageFlags::TESSELLATION_CONTROL.0,
3407 "TESSELLATION_CONTROL",
3408 ),
3409 (
3410 ShaderStageFlags::TESSELLATION_EVALUATION.0,
3411 "TESSELLATION_EVALUATION",
3412 ),
3413 (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"),
3414 (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"),
3415 (ShaderStageFlags::COMPUTE.0, "COMPUTE"),
3416 (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"),
3417 (ShaderStageFlags::ALL.0, "ALL"),
3418 (ShaderStageFlags::RAYGEN_KHR.0, "RAYGEN_KHR"),
3419 (ShaderStageFlags::ANY_HIT_KHR.0, "ANY_HIT_KHR"),
3420 (ShaderStageFlags::CLOSEST_HIT_KHR.0, "CLOSEST_HIT_KHR"),
3421 (ShaderStageFlags::MISS_KHR.0, "MISS_KHR"),
3422 (ShaderStageFlags::INTERSECTION_KHR.0, "INTERSECTION_KHR"),
3423 (ShaderStageFlags::CALLABLE_KHR.0, "CALLABLE_KHR"),
3424 (ShaderStageFlags::TASK_NV.0, "TASK_NV"),
3425 (ShaderStageFlags::MESH_NV.0, "MESH_NV"),
3426 ];
3427 debug_flags(f, KNOWN, self.0)
3428 }
3429 }
3430 impl fmt::Debug for ShadingRatePaletteEntryNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3431 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3432 let name = match *self {
3433 Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"),
3434 Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"),
3435 Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"),
3436 Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"),
3437 Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"),
3438 Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"),
3439 Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"),
3440 Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"),
3441 Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"),
3442 Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"),
3443 Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"),
3444 Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"),
3445 _ => None,
3446 };
3447 if let Some(x) = name {
3448 f.write_str(x)
3449 } else {
3450 self.0.fmt(f)
3451 }
3452 }
3453 }
3454 impl fmt::Debug for SharingMode {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3455 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3456 let name = match *self {
3457 Self::EXCLUSIVE => Some("EXCLUSIVE"),
3458 Self::CONCURRENT => Some("CONCURRENT"),
3459 _ => None,
3460 };
3461 if let Some(x) = name {
3462 f.write_str(x)
3463 } else {
3464 self.0.fmt(f)
3465 }
3466 }
3467 }
3468 impl fmt::Debug for SparseImageFormatFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3469 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3470 const KNOWN: &[(Flags, &str)] = &[
3471 (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"),
3472 (
3473 SparseImageFormatFlags::ALIGNED_MIP_SIZE.0,
3474 "ALIGNED_MIP_SIZE",
3475 ),
3476 (
3477 SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0,
3478 "NONSTANDARD_BLOCK_SIZE",
3479 ),
3480 ];
3481 debug_flags(f, KNOWN, self.0)
3482 }
3483 }
3484 impl fmt::Debug for SparseMemoryBindFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3485 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3486 const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")];
3487 debug_flags(f, KNOWN, self.0)
3488 }
3489 }
3490 impl fmt::Debug for StencilFaceFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3491 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3492 const KNOWN: &[(Flags, &str)] = &[
3493 (StencilFaceFlags::FRONT.0, "FRONT"),
3494 (StencilFaceFlags::BACK.0, "BACK"),
3495 (StencilFaceFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"),
3496 ];
3497 debug_flags(f, KNOWN, self.0)
3498 }
3499 }
3500 impl fmt::Debug for StencilOp {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3501 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3502 let name = match *self {
3503 Self::KEEP => Some("KEEP"),
3504 Self::ZERO => Some("ZERO"),
3505 Self::REPLACE => Some("REPLACE"),
3506 Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"),
3507 Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"),
3508 Self::INVERT => Some("INVERT"),
3509 Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"),
3510 Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"),
3511 _ => None,
3512 };
3513 if let Some(x) = name {
3514 f.write_str(x)
3515 } else {
3516 self.0.fmt(f)
3517 }
3518 }
3519 }
3520 impl fmt::Debug for StreamDescriptorSurfaceCreateFlagsGGP {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3521 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3522 const KNOWN: &[(Flags, &str)] = &[];
3523 debug_flags(f, KNOWN, self.0)
3524 }
3525 }
3526 impl fmt::Debug for StructureType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3527 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3528 let name = match *self {
3529 Self::APPLICATION_INFO => Some("APPLICATION_INFO"),
3530 Self::INSTANCE_CREATE_INFO => Some("INSTANCE_CREATE_INFO"),
3531 Self::DEVICE_QUEUE_CREATE_INFO => Some("DEVICE_QUEUE_CREATE_INFO"),
3532 Self::DEVICE_CREATE_INFO => Some("DEVICE_CREATE_INFO"),
3533 Self::SUBMIT_INFO => Some("SUBMIT_INFO"),
3534 Self::MEMORY_ALLOCATE_INFO => Some("MEMORY_ALLOCATE_INFO"),
3535 Self::MAPPED_MEMORY_RANGE => Some("MAPPED_MEMORY_RANGE"),
3536 Self::BIND_SPARSE_INFO => Some("BIND_SPARSE_INFO"),
3537 Self::FENCE_CREATE_INFO => Some("FENCE_CREATE_INFO"),
3538 Self::SEMAPHORE_CREATE_INFO => Some("SEMAPHORE_CREATE_INFO"),
3539 Self::EVENT_CREATE_INFO => Some("EVENT_CREATE_INFO"),
3540 Self::QUERY_POOL_CREATE_INFO => Some("QUERY_POOL_CREATE_INFO"),
3541 Self::BUFFER_CREATE_INFO => Some("BUFFER_CREATE_INFO"),
3542 Self::BUFFER_VIEW_CREATE_INFO => Some("BUFFER_VIEW_CREATE_INFO"),
3543 Self::IMAGE_CREATE_INFO => Some("IMAGE_CREATE_INFO"),
3544 Self::IMAGE_VIEW_CREATE_INFO => Some("IMAGE_VIEW_CREATE_INFO"),
3545 Self::SHADER_MODULE_CREATE_INFO => Some("SHADER_MODULE_CREATE_INFO"),
3546 Self::PIPELINE_CACHE_CREATE_INFO => Some("PIPELINE_CACHE_CREATE_INFO"),
3547 Self::PIPELINE_SHADER_STAGE_CREATE_INFO => Some("PIPELINE_SHADER_STAGE_CREATE_INFO"),
3548 Self::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => {
3549 Some("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO")
3550 }
3551 Self::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => {
3552 Some("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO")
3553 }
3554 Self::PIPELINE_TESSELLATION_STATE_CREATE_INFO => {
3555 Some("PIPELINE_TESSELLATION_STATE_CREATE_INFO")
3556 }
3557 Self::PIPELINE_VIEWPORT_STATE_CREATE_INFO => {
3558 Some("PIPELINE_VIEWPORT_STATE_CREATE_INFO")
3559 }
3560 Self::PIPELINE_RASTERIZATION_STATE_CREATE_INFO => {
3561 Some("PIPELINE_RASTERIZATION_STATE_CREATE_INFO")
3562 }
3563 Self::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => {
3564 Some("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO")
3565 }
3566 Self::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => {
3567 Some("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO")
3568 }
3569 Self::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => {
3570 Some("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO")
3571 }
3572 Self::PIPELINE_DYNAMIC_STATE_CREATE_INFO => Some("PIPELINE_DYNAMIC_STATE_CREATE_INFO"),
3573 Self::GRAPHICS_PIPELINE_CREATE_INFO => Some("GRAPHICS_PIPELINE_CREATE_INFO"),
3574 Self::COMPUTE_PIPELINE_CREATE_INFO => Some("COMPUTE_PIPELINE_CREATE_INFO"),
3575 Self::PIPELINE_LAYOUT_CREATE_INFO => Some("PIPELINE_LAYOUT_CREATE_INFO"),
3576 Self::SAMPLER_CREATE_INFO => Some("SAMPLER_CREATE_INFO"),
3577 Self::DESCRIPTOR_SET_LAYOUT_CREATE_INFO => Some("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"),
3578 Self::DESCRIPTOR_POOL_CREATE_INFO => Some("DESCRIPTOR_POOL_CREATE_INFO"),
3579 Self::DESCRIPTOR_SET_ALLOCATE_INFO => Some("DESCRIPTOR_SET_ALLOCATE_INFO"),
3580 Self::WRITE_DESCRIPTOR_SET => Some("WRITE_DESCRIPTOR_SET"),
3581 Self::COPY_DESCRIPTOR_SET => Some("COPY_DESCRIPTOR_SET"),
3582 Self::FRAMEBUFFER_CREATE_INFO => Some("FRAMEBUFFER_CREATE_INFO"),
3583 Self::RENDER_PASS_CREATE_INFO => Some("RENDER_PASS_CREATE_INFO"),
3584 Self::COMMAND_POOL_CREATE_INFO => Some("COMMAND_POOL_CREATE_INFO"),
3585 Self::COMMAND_BUFFER_ALLOCATE_INFO => Some("COMMAND_BUFFER_ALLOCATE_INFO"),
3586 Self::COMMAND_BUFFER_INHERITANCE_INFO => Some("COMMAND_BUFFER_INHERITANCE_INFO"),
3587 Self::COMMAND_BUFFER_BEGIN_INFO => Some("COMMAND_BUFFER_BEGIN_INFO"),
3588 Self::RENDER_PASS_BEGIN_INFO => Some("RENDER_PASS_BEGIN_INFO"),
3589 Self::BUFFER_MEMORY_BARRIER => Some("BUFFER_MEMORY_BARRIER"),
3590 Self::IMAGE_MEMORY_BARRIER => Some("IMAGE_MEMORY_BARRIER"),
3591 Self::MEMORY_BARRIER => Some("MEMORY_BARRIER"),
3592 Self::LOADER_INSTANCE_CREATE_INFO => Some("LOADER_INSTANCE_CREATE_INFO"),
3593 Self::LOADER_DEVICE_CREATE_INFO => Some("LOADER_DEVICE_CREATE_INFO"),
3594 Self::SWAPCHAIN_CREATE_INFO_KHR => Some("SWAPCHAIN_CREATE_INFO_KHR"),
3595 Self::PRESENT_INFO_KHR => Some("PRESENT_INFO_KHR"),
3596 Self::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR => {
3597 Some("DEVICE_GROUP_PRESENT_CAPABILITIES_KHR")
3598 }
3599 Self::IMAGE_SWAPCHAIN_CREATE_INFO_KHR => Some("IMAGE_SWAPCHAIN_CREATE_INFO_KHR"),
3600 Self::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR => {
3601 Some("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR")
3602 }
3603 Self::ACQUIRE_NEXT_IMAGE_INFO_KHR => Some("ACQUIRE_NEXT_IMAGE_INFO_KHR"),
3604 Self::DEVICE_GROUP_PRESENT_INFO_KHR => Some("DEVICE_GROUP_PRESENT_INFO_KHR"),
3605 Self::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR => {
3606 Some("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR")
3607 }
3608 Self::DISPLAY_MODE_CREATE_INFO_KHR => Some("DISPLAY_MODE_CREATE_INFO_KHR"),
3609 Self::DISPLAY_SURFACE_CREATE_INFO_KHR => Some("DISPLAY_SURFACE_CREATE_INFO_KHR"),
3610 Self::DISPLAY_PRESENT_INFO_KHR => Some("DISPLAY_PRESENT_INFO_KHR"),
3611 Self::XLIB_SURFACE_CREATE_INFO_KHR => Some("XLIB_SURFACE_CREATE_INFO_KHR"),
3612 Self::XCB_SURFACE_CREATE_INFO_KHR => Some("XCB_SURFACE_CREATE_INFO_KHR"),
3613 Self::WAYLAND_SURFACE_CREATE_INFO_KHR => Some("WAYLAND_SURFACE_CREATE_INFO_KHR"),
3614 Self::ANDROID_SURFACE_CREATE_INFO_KHR => Some("ANDROID_SURFACE_CREATE_INFO_KHR"),
3615 Self::WIN32_SURFACE_CREATE_INFO_KHR => Some("WIN32_SURFACE_CREATE_INFO_KHR"),
3616 Self::NATIVE_BUFFER_ANDROID => Some("NATIVE_BUFFER_ANDROID"),
3617 Self::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID => {
3618 Some("SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID")
3619 }
3620 Self::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID => {
3621 Some("PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID")
3622 }
3623 Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT => {
3624 Some("DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT")
3625 }
3626 Self::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD => {
3627 Some("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD")
3628 }
3629 Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => Some("DEBUG_MARKER_OBJECT_NAME_INFO_EXT"),
3630 Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => Some("DEBUG_MARKER_OBJECT_TAG_INFO_EXT"),
3631 Self::DEBUG_MARKER_MARKER_INFO_EXT => Some("DEBUG_MARKER_MARKER_INFO_EXT"),
3632 Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => {
3633 Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV")
3634 }
3635 Self::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV => {
3636 Some("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV")
3637 }
3638 Self::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV => {
3639 Some("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV")
3640 }
3641 Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT => {
3642 Some("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT")
3643 }
3644 Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT => {
3645 Some("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT")
3646 }
3647 Self::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT => {
3648 Some("PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT")
3649 }
3650 Self::IMAGE_VIEW_HANDLE_INFO_NVX => Some("IMAGE_VIEW_HANDLE_INFO_NVX"),
3651 Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => Some("IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"),
3652 Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => {
3653 Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD")
3654 }
3655 Self::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP => {
3656 Some("STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP")
3657 }
3658 Self::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV => {
3659 Some("PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV")
3660 }
3661 Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV => {
3662 Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV")
3663 }
3664 Self::EXPORT_MEMORY_ALLOCATE_INFO_NV => Some("EXPORT_MEMORY_ALLOCATE_INFO_NV"),
3665 Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"),
3666 Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"),
3667 Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV => {
3668 Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV")
3669 }
3670 Self::VALIDATION_FLAGS_EXT => Some("VALIDATION_FLAGS_EXT"),
3671 Self::VI_SURFACE_CREATE_INFO_NN => Some("VI_SURFACE_CREATE_INFO_NN"),
3672 Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT => {
3673 Some("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT")
3674 }
3675 Self::IMAGE_VIEW_ASTC_DECODE_MODE_EXT => Some("IMAGE_VIEW_ASTC_DECODE_MODE_EXT"),
3676 Self::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT => {
3677 Some("PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT")
3678 }
3679 Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => {
3680 Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR")
3681 }
3682 Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR => {
3683 Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR")
3684 }
3685 Self::MEMORY_WIN32_HANDLE_PROPERTIES_KHR => Some("MEMORY_WIN32_HANDLE_PROPERTIES_KHR"),
3686 Self::MEMORY_GET_WIN32_HANDLE_INFO_KHR => Some("MEMORY_GET_WIN32_HANDLE_INFO_KHR"),
3687 Self::IMPORT_MEMORY_FD_INFO_KHR => Some("IMPORT_MEMORY_FD_INFO_KHR"),
3688 Self::MEMORY_FD_PROPERTIES_KHR => Some("MEMORY_FD_PROPERTIES_KHR"),
3689 Self::MEMORY_GET_FD_INFO_KHR => Some("MEMORY_GET_FD_INFO_KHR"),
3690 Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR => {
3691 Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR")
3692 }
3693 Self::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => {
3694 Some("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR")
3695 }
3696 Self::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => {
3697 Some("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR")
3698 }
3699 Self::D3D12_FENCE_SUBMIT_INFO_KHR => Some("D3D12_FENCE_SUBMIT_INFO_KHR"),
3700 Self::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR => {
3701 Some("SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR")
3702 }
3703 Self::IMPORT_SEMAPHORE_FD_INFO_KHR => Some("IMPORT_SEMAPHORE_FD_INFO_KHR"),
3704 Self::SEMAPHORE_GET_FD_INFO_KHR => Some("SEMAPHORE_GET_FD_INFO_KHR"),
3705 Self::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR => {
3706 Some("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR")
3707 }
3708 Self::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT => {
3709 Some("COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT")
3710 }
3711 Self::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT => {
3712 Some("PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT")
3713 }
3714 Self::CONDITIONAL_RENDERING_BEGIN_INFO_EXT => {
3715 Some("CONDITIONAL_RENDERING_BEGIN_INFO_EXT")
3716 }
3717 Self::PRESENT_REGIONS_KHR => Some("PRESENT_REGIONS_KHR"),
3718 Self::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV => {
3719 Some("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV")
3720 }
3721 Self::SURFACE_CAPABILITIES_2_EXT => Some("SURFACE_CAPABILITIES_2_EXT"),
3722 Self::DISPLAY_POWER_INFO_EXT => Some("DISPLAY_POWER_INFO_EXT"),
3723 Self::DEVICE_EVENT_INFO_EXT => Some("DEVICE_EVENT_INFO_EXT"),
3724 Self::DISPLAY_EVENT_INFO_EXT => Some("DISPLAY_EVENT_INFO_EXT"),
3725 Self::SWAPCHAIN_COUNTER_CREATE_INFO_EXT => Some("SWAPCHAIN_COUNTER_CREATE_INFO_EXT"),
3726 Self::PRESENT_TIMES_INFO_GOOGLE => Some("PRESENT_TIMES_INFO_GOOGLE"),
3727 Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX => {
3728 Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX")
3729 }
3730 Self::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV => {
3731 Some("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV")
3732 }
3733 Self::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT => {
3734 Some("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT")
3735 }
3736 Self::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT => {
3737 Some("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT")
3738 }
3739 Self::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT => {
3740 Some("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT")
3741 }
3742 Self::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT => {
3743 Some("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT")
3744 }
3745 Self::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT => {
3746 Some("PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT")
3747 }
3748 Self::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT => {
3749 Some("PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT")
3750 }
3751 Self::HDR_METADATA_EXT => Some("HDR_METADATA_EXT"),
3752 Self::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR => {
3753 Some("SHARED_PRESENT_SURFACE_CAPABILITIES_KHR")
3754 }
3755 Self::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"),
3756 Self::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"),
3757 Self::FENCE_GET_WIN32_HANDLE_INFO_KHR => Some("FENCE_GET_WIN32_HANDLE_INFO_KHR"),
3758 Self::IMPORT_FENCE_FD_INFO_KHR => Some("IMPORT_FENCE_FD_INFO_KHR"),
3759 Self::FENCE_GET_FD_INFO_KHR => Some("FENCE_GET_FD_INFO_KHR"),
3760 Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR => {
3761 Some("PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR")
3762 }
3763 Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR => {
3764 Some("PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR")
3765 }
3766 Self::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR => {
3767 Some("QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR")
3768 }
3769 Self::PERFORMANCE_QUERY_SUBMIT_INFO_KHR => Some("PERFORMANCE_QUERY_SUBMIT_INFO_KHR"),
3770 Self::ACQUIRE_PROFILING_LOCK_INFO_KHR => Some("ACQUIRE_PROFILING_LOCK_INFO_KHR"),
3771 Self::PERFORMANCE_COUNTER_KHR => Some("PERFORMANCE_COUNTER_KHR"),
3772 Self::PERFORMANCE_COUNTER_DESCRIPTION_KHR => {
3773 Some("PERFORMANCE_COUNTER_DESCRIPTION_KHR")
3774 }
3775 Self::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR => Some("PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"),
3776 Self::SURFACE_CAPABILITIES_2_KHR => Some("SURFACE_CAPABILITIES_2_KHR"),
3777 Self::SURFACE_FORMAT_2_KHR => Some("SURFACE_FORMAT_2_KHR"),
3778 Self::DISPLAY_PROPERTIES_2_KHR => Some("DISPLAY_PROPERTIES_2_KHR"),
3779 Self::DISPLAY_PLANE_PROPERTIES_2_KHR => Some("DISPLAY_PLANE_PROPERTIES_2_KHR"),
3780 Self::DISPLAY_MODE_PROPERTIES_2_KHR => Some("DISPLAY_MODE_PROPERTIES_2_KHR"),
3781 Self::DISPLAY_PLANE_INFO_2_KHR => Some("DISPLAY_PLANE_INFO_2_KHR"),
3782 Self::DISPLAY_PLANE_CAPABILITIES_2_KHR => Some("DISPLAY_PLANE_CAPABILITIES_2_KHR"),
3783 Self::IOS_SURFACE_CREATE_INFO_MVK => Some("IOS_SURFACE_CREATE_INFO_MVK"),
3784 Self::MACOS_SURFACE_CREATE_INFO_MVK => Some("MACOS_SURFACE_CREATE_INFO_MVK"),
3785 Self::DEBUG_UTILS_OBJECT_NAME_INFO_EXT => Some("DEBUG_UTILS_OBJECT_NAME_INFO_EXT"),
3786 Self::DEBUG_UTILS_OBJECT_TAG_INFO_EXT => Some("DEBUG_UTILS_OBJECT_TAG_INFO_EXT"),
3787 Self::DEBUG_UTILS_LABEL_EXT => Some("DEBUG_UTILS_LABEL_EXT"),
3788 Self::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT => {
3789 Some("DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT")
3790 }
3791 Self::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT => {
3792 Some("DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT")
3793 }
3794 Self::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID => {
3795 Some("ANDROID_HARDWARE_BUFFER_USAGE_ANDROID")
3796 }
3797 Self::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID => {
3798 Some("ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID")
3799 }
3800 Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID => {
3801 Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID")
3802 }
3803 Self::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => {
3804 Some("IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID")
3805 }
3806 Self::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => {
3807 Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID")
3808 }
3809 Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"),
3810 Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT => {
3811 Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT")
3812 }
3813 Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT => {
3814 Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT")
3815 }
3816 Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT => {
3817 Some("WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT")
3818 }
3819 Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT => {
3820 Some("DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT")
3821 }
3822 Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"),
3823 Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => {
3824 Some("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT")
3825 }
3826 Self::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT => {
3827 Some("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT")
3828 }
3829 Self::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT => {
3830 Some("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT")
3831 }
3832 Self::MULTISAMPLE_PROPERTIES_EXT => Some("MULTISAMPLE_PROPERTIES_EXT"),
3833 Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT => {
3834 Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT")
3835 }
3836 Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT => {
3837 Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT")
3838 }
3839 Self::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT => {
3840 Some("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT")
3841 }
3842 Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => {
3843 Some("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV")
3844 }
3845 Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR => {
3846 Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR")
3847 }
3848 Self::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR => {
3849 Some("ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR")
3850 }
3851 Self::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR => {
3852 Some("ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR")
3853 }
3854 Self::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR => {
3855 Some("ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR")
3856 }
3857 Self::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR => {
3858 Some("ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR")
3859 }
3860 Self::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR => {
3861 Some("ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR")
3862 }
3863 Self::ACCELERATION_STRUCTURE_GEOMETRY_KHR => {
3864 Some("ACCELERATION_STRUCTURE_GEOMETRY_KHR")
3865 }
3866 Self::ACCELERATION_STRUCTURE_VERSION_INFO_KHR => {
3867 Some("ACCELERATION_STRUCTURE_VERSION_INFO_KHR")
3868 }
3869 Self::COPY_ACCELERATION_STRUCTURE_INFO_KHR => {
3870 Some("COPY_ACCELERATION_STRUCTURE_INFO_KHR")
3871 }
3872 Self::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR => {
3873 Some("COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR")
3874 }
3875 Self::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR => {
3876 Some("COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR")
3877 }
3878 Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR => {
3879 Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR")
3880 }
3881 Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR => {
3882 Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR")
3883 }
3884 Self::ACCELERATION_STRUCTURE_CREATE_INFO_KHR => {
3885 Some("ACCELERATION_STRUCTURE_CREATE_INFO_KHR")
3886 }
3887 Self::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR => {
3888 Some("ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR")
3889 }
3890 Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR => {
3891 Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR")
3892 }
3893 Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR => {
3894 Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR")
3895 }
3896 Self::RAY_TRACING_PIPELINE_CREATE_INFO_KHR => {
3897 Some("RAY_TRACING_PIPELINE_CREATE_INFO_KHR")
3898 }
3899 Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR => {
3900 Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR")
3901 }
3902 Self::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR => {
3903 Some("RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR")
3904 }
3905 Self::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR => {
3906 Some("PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR")
3907 }
3908 Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => {
3909 Some("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV")
3910 }
3911 Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV => {
3912 Some("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV")
3913 }
3914 Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV => {
3915 Some("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV")
3916 }
3917 Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT => {
3918 Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT")
3919 }
3920 Self::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT => {
3921 Some("PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT")
3922 }
3923 Self::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT => {
3924 Some("IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT")
3925 }
3926 Self::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT => {
3927 Some("IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT")
3928 }
3929 Self::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT => {
3930 Some("IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT")
3931 }
3932 Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"),
3933 Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => {
3934 Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT")
3935 }
3936 Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR => {
3937 Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR")
3938 }
3939 Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR => {
3940 Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR")
3941 }
3942 Self::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV => {
3943 Some("PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV")
3944 }
3945 Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV => {
3946 Some("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV")
3947 }
3948 Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV => {
3949 Some("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV")
3950 }
3951 Self::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV => {
3952 Some("PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV")
3953 }
3954 Self::RAY_TRACING_PIPELINE_CREATE_INFO_NV => {
3955 Some("RAY_TRACING_PIPELINE_CREATE_INFO_NV")
3956 }
3957 Self::ACCELERATION_STRUCTURE_CREATE_INFO_NV => {
3958 Some("ACCELERATION_STRUCTURE_CREATE_INFO_NV")
3959 }
3960 Self::GEOMETRY_NV => Some("GEOMETRY_NV"),
3961 Self::GEOMETRY_TRIANGLES_NV => Some("GEOMETRY_TRIANGLES_NV"),
3962 Self::GEOMETRY_AABB_NV => Some("GEOMETRY_AABB_NV"),
3963 Self::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV => {
3964 Some("BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV")
3965 }
3966 Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV => {
3967 Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV")
3968 }
3969 Self::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV => {
3970 Some("ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV")
3971 }
3972 Self::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV => {
3973 Some("PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV")
3974 }
3975 Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV => {
3976 Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV")
3977 }
3978 Self::ACCELERATION_STRUCTURE_INFO_NV => Some("ACCELERATION_STRUCTURE_INFO_NV"),
3979 Self::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV => {
3980 Some("PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV")
3981 }
3982 Self::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV => {
3983 Some("PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV")
3984 }
3985 Self::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT => {
3986 Some("PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT")
3987 }
3988 Self::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT => {
3989 Some("FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT")
3990 }
3991 Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT => {
3992 Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT")
3993 }
3994 Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => {
3995 Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT")
3996 }
3997 Self::MEMORY_HOST_POINTER_PROPERTIES_EXT => Some("MEMORY_HOST_POINTER_PROPERTIES_EXT"),
3998 Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT => {
3999 Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT")
4000 }
4001 Self::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR => {
4002 Some("PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR")
4003 }
4004 Self::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD => {
4005 Some("PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD")
4006 }
4007 Self::CALIBRATED_TIMESTAMP_INFO_EXT => Some("CALIBRATED_TIMESTAMP_INFO_EXT"),
4008 Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => {
4009 Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD")
4010 }
4011 Self::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD => {
4012 Some("DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD")
4013 }
4014 Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT => {
4015 Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT")
4016 }
4017 Self::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT => {
4018 Some("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT")
4019 }
4020 Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT => {
4021 Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT")
4022 }
4023 Self::PRESENT_FRAME_TOKEN_GGP => Some("PRESENT_FRAME_TOKEN_GGP"),
4024 Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT => {
4025 Some("PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT")
4026 }
4027 Self::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV => {
4028 Some("PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV")
4029 }
4030 Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV => {
4031 Some("PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV")
4032 }
4033 Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV => {
4034 Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV")
4035 }
4036 Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV => {
4037 Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV")
4038 }
4039 Self::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV => {
4040 Some("PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV")
4041 }
4042 Self::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV => {
4043 Some("PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV")
4044 }
4045 Self::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV => {
4046 Some("PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV")
4047 }
4048 Self::CHECKPOINT_DATA_NV => Some("CHECKPOINT_DATA_NV"),
4049 Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV => {
4050 Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV")
4051 }
4052 Self::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL => {
4053 Some("PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL")
4054 }
4055 Self::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL => {
4056 Some("QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL")
4057 }
4058 Self::INITIALIZE_PERFORMANCE_API_INFO_INTEL => {
4059 Some("INITIALIZE_PERFORMANCE_API_INFO_INTEL")
4060 }
4061 Self::PERFORMANCE_MARKER_INFO_INTEL => Some("PERFORMANCE_MARKER_INFO_INTEL"),
4062 Self::PERFORMANCE_STREAM_MARKER_INFO_INTEL => {
4063 Some("PERFORMANCE_STREAM_MARKER_INFO_INTEL")
4064 }
4065 Self::PERFORMANCE_OVERRIDE_INFO_INTEL => Some("PERFORMANCE_OVERRIDE_INFO_INTEL"),
4066 Self::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL => {
4067 Some("PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL")
4068 }
4069 Self::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT => {
4070 Some("PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT")
4071 }
4072 Self::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD => {
4073 Some("DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD")
4074 }
4075 Self::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD => {
4076 Some("SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD")
4077 }
4078 Self::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA => {
4079 Some("IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA")
4080 }
4081 Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR => {
4082 Some("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR")
4083 }
4084 Self::METAL_SURFACE_CREATE_INFO_EXT => Some("METAL_SURFACE_CREATE_INFO_EXT"),
4085 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT => {
4086 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT")
4087 }
4088 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT => {
4089 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT")
4090 }
4091 Self::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT => {
4092 Some("RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT")
4093 }
4094 Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT => {
4095 Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT")
4096 }
4097 Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT => {
4098 Some("PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT")
4099 }
4100 Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT => {
4101 Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT")
4102 }
4103 Self::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => {
4104 Some("FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR")
4105 }
4106 Self::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR => {
4107 Some("PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR")
4108 }
4109 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR => {
4110 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR")
4111 }
4112 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR => {
4113 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR")
4114 }
4115 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR => {
4116 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR")
4117 }
4118 Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD => {
4119 Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD")
4120 }
4121 Self::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD => {
4122 Some("PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD")
4123 }
4124 Self::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT => {
4125 Some("PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT")
4126 }
4127 Self::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT => {
4128 Some("PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT")
4129 }
4130 Self::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT => {
4131 Some("PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT")
4132 }
4133 Self::MEMORY_PRIORITY_ALLOCATE_INFO_EXT => Some("MEMORY_PRIORITY_ALLOCATE_INFO_EXT"),
4134 Self::SURFACE_PROTECTED_CAPABILITIES_KHR => Some("SURFACE_PROTECTED_CAPABILITIES_KHR"),
4135 Self::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV => {
4136 Some("PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV")
4137 }
4138 Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT => {
4139 Some("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT")
4140 }
4141 Self::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT => {
4142 Some("BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT")
4143 }
4144 Self::PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT => {
4145 Some("PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT")
4146 }
4147 Self::VALIDATION_FEATURES_EXT => Some("VALIDATION_FEATURES_EXT"),
4148 Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV => {
4149 Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV")
4150 }
4151 Self::COOPERATIVE_MATRIX_PROPERTIES_NV => Some("COOPERATIVE_MATRIX_PROPERTIES_NV"),
4152 Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV => {
4153 Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV")
4154 }
4155 Self::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV => {
4156 Some("PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV")
4157 }
4158 Self::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV => {
4159 Some("PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV")
4160 }
4161 Self::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV => {
4162 Some("FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV")
4163 }
4164 Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT => {
4165 Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT")
4166 }
4167 Self::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT => {
4168 Some("PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT")
4169 }
4170 Self::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT => {
4171 Some("SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT")
4172 }
4173 Self::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT => {
4174 Some("SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT")
4175 }
4176 Self::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT => {
4177 Some("SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT")
4178 }
4179 Self::HEADLESS_SURFACE_CREATE_INFO_EXT => Some("HEADLESS_SURFACE_CREATE_INFO_EXT"),
4180 Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT => {
4181 Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT")
4182 }
4183 Self::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT => {
4184 Some("PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT")
4185 }
4186 Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT => {
4187 Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT")
4188 }
4189 Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT => {
4190 Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT")
4191 }
4192 Self::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT => {
4193 Some("PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT")
4194 }
4195 Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT => {
4196 Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT")
4197 }
4198 Self::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR => {
4199 Some("PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR")
4200 }
4201 Self::PIPELINE_INFO_KHR => Some("PIPELINE_INFO_KHR"),
4202 Self::PIPELINE_EXECUTABLE_PROPERTIES_KHR => Some("PIPELINE_EXECUTABLE_PROPERTIES_KHR"),
4203 Self::PIPELINE_EXECUTABLE_INFO_KHR => Some("PIPELINE_EXECUTABLE_INFO_KHR"),
4204 Self::PIPELINE_EXECUTABLE_STATISTIC_KHR => Some("PIPELINE_EXECUTABLE_STATISTIC_KHR"),
4205 Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => {
4206 Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR")
4207 }
4208 Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT => {
4209 Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT")
4210 }
4211 Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV => {
4212 Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV")
4213 }
4214 Self::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV => {
4215 Some("GRAPHICS_SHADER_GROUP_CREATE_INFO_NV")
4216 }
4217 Self::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV => {
4218 Some("GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV")
4219 }
4220 Self::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV => Some("INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"),
4221 Self::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV => {
4222 Some("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV")
4223 }
4224 Self::GENERATED_COMMANDS_INFO_NV => Some("GENERATED_COMMANDS_INFO_NV"),
4225 Self::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV => {
4226 Some("GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV")
4227 }
4228 Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV => {
4229 Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV")
4230 }
4231 Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT => {
4232 Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT")
4233 }
4234 Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT => {
4235 Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT")
4236 }
4237 Self::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM => {
4238 Some("COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM")
4239 }
4240 Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => {
4241 Some("RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM")
4242 }
4243 Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => {
4244 Some("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT")
4245 }
4246 Self::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT => {
4247 Some("DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT")
4248 }
4249 Self::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT => {
4250 Some("DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT")
4251 }
4252 Self::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT => {
4253 Some("PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT")
4254 }
4255 Self::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT => {
4256 Some("PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT")
4257 }
4258 Self::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT => {
4259 Some("SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT")
4260 }
4261 Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT => {
4262 Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT")
4263 }
4264 Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT => {
4265 Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT")
4266 }
4267 Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"),
4268 Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT => {
4269 Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT")
4270 }
4271 Self::DEVICE_PRIVATE_DATA_CREATE_INFO_EXT => {
4272 Some("DEVICE_PRIVATE_DATA_CREATE_INFO_EXT")
4273 }
4274 Self::PRIVATE_DATA_SLOT_CREATE_INFO_EXT => Some("PRIVATE_DATA_SLOT_CREATE_INFO_EXT"),
4275 Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT => {
4276 Some("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT")
4277 }
4278 Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => {
4279 Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV")
4280 }
4281 Self::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV => {
4282 Some("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV")
4283 }
4284 Self::RESERVED_QCOM => Some("RESERVED_QCOM"),
4285 Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR => {
4286 Some("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR")
4287 }
4288 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV => {
4289 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV")
4290 }
4291 Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV => {
4292 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV")
4293 }
4294 Self::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV => {
4295 Some("PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV")
4296 }
4297 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT => {
4298 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT")
4299 }
4300 Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT => {
4301 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT")
4302 }
4303 Self::COPY_COMMAND_TRANSFORM_INFO_QCOM => Some("COPY_COMMAND_TRANSFORM_INFO_QCOM"),
4304 Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT => {
4305 Some("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT")
4306 }
4307 Self::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR => {
4308 Some("PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR")
4309 }
4310 Self::COPY_BUFFER_INFO_2_KHR => Some("COPY_BUFFER_INFO_2_KHR"),
4311 Self::COPY_IMAGE_INFO_2_KHR => Some("COPY_IMAGE_INFO_2_KHR"),
4312 Self::COPY_BUFFER_TO_IMAGE_INFO_2_KHR => Some("COPY_BUFFER_TO_IMAGE_INFO_2_KHR"),
4313 Self::COPY_IMAGE_TO_BUFFER_INFO_2_KHR => Some("COPY_IMAGE_TO_BUFFER_INFO_2_KHR"),
4314 Self::BLIT_IMAGE_INFO_2_KHR => Some("BLIT_IMAGE_INFO_2_KHR"),
4315 Self::RESOLVE_IMAGE_INFO_2_KHR => Some("RESOLVE_IMAGE_INFO_2_KHR"),
4316 Self::BUFFER_COPY_2_KHR => Some("BUFFER_COPY_2_KHR"),
4317 Self::IMAGE_COPY_2_KHR => Some("IMAGE_COPY_2_KHR"),
4318 Self::IMAGE_BLIT_2_KHR => Some("IMAGE_BLIT_2_KHR"),
4319 Self::BUFFER_IMAGE_COPY_2_KHR => Some("BUFFER_IMAGE_COPY_2_KHR"),
4320 Self::IMAGE_RESOLVE_2_KHR => Some("IMAGE_RESOLVE_2_KHR"),
4321 Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => {
4322 Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT")
4323 }
4324 Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"),
4325 Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE => {
4326 Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE")
4327 }
4328 Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE => {
4329 Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE")
4330 }
4331 Self::SCREEN_SURFACE_CREATE_INFO_QNX => Some("SCREEN_SURFACE_CREATE_INFO_QNX"),
4332 Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => {
4333 Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES")
4334 }
4335 Self::BIND_BUFFER_MEMORY_INFO => Some("BIND_BUFFER_MEMORY_INFO"),
4336 Self::BIND_IMAGE_MEMORY_INFO => Some("BIND_IMAGE_MEMORY_INFO"),
4337 Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => {
4338 Some("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES")
4339 }
4340 Self::MEMORY_DEDICATED_REQUIREMENTS => Some("MEMORY_DEDICATED_REQUIREMENTS"),
4341 Self::MEMORY_DEDICATED_ALLOCATE_INFO => Some("MEMORY_DEDICATED_ALLOCATE_INFO"),
4342 Self::MEMORY_ALLOCATE_FLAGS_INFO => Some("MEMORY_ALLOCATE_FLAGS_INFO"),
4343 Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => {
4344 Some("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO")
4345 }
4346 Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => {
4347 Some("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO")
4348 }
4349 Self::DEVICE_GROUP_SUBMIT_INFO => Some("DEVICE_GROUP_SUBMIT_INFO"),
4350 Self::DEVICE_GROUP_BIND_SPARSE_INFO => Some("DEVICE_GROUP_BIND_SPARSE_INFO"),
4351 Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => {
4352 Some("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO")
4353 }
4354 Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => {
4355 Some("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO")
4356 }
4357 Self::PHYSICAL_DEVICE_GROUP_PROPERTIES => Some("PHYSICAL_DEVICE_GROUP_PROPERTIES"),
4358 Self::DEVICE_GROUP_DEVICE_CREATE_INFO => Some("DEVICE_GROUP_DEVICE_CREATE_INFO"),
4359 Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2 => Some("BUFFER_MEMORY_REQUIREMENTS_INFO_2"),
4360 Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2 => Some("IMAGE_MEMORY_REQUIREMENTS_INFO_2"),
4361 Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => {
4362 Some("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2")
4363 }
4364 Self::MEMORY_REQUIREMENTS_2 => Some("MEMORY_REQUIREMENTS_2"),
4365 Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 => Some("SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"),
4366 Self::PHYSICAL_DEVICE_FEATURES_2 => Some("PHYSICAL_DEVICE_FEATURES_2"),
4367 Self::PHYSICAL_DEVICE_PROPERTIES_2 => Some("PHYSICAL_DEVICE_PROPERTIES_2"),
4368 Self::FORMAT_PROPERTIES_2 => Some("FORMAT_PROPERTIES_2"),
4369 Self::IMAGE_FORMAT_PROPERTIES_2 => Some("IMAGE_FORMAT_PROPERTIES_2"),
4370 Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 => {
4371 Some("PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2")
4372 }
4373 Self::QUEUE_FAMILY_PROPERTIES_2 => Some("QUEUE_FAMILY_PROPERTIES_2"),
4374 Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 => {
4375 Some("PHYSICAL_DEVICE_MEMORY_PROPERTIES_2")
4376 }
4377 Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2 => Some("SPARSE_IMAGE_FORMAT_PROPERTIES_2"),
4378 Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 => {
4379 Some("PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2")
4380 }
4381 Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES => {
4382 Some("PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES")
4383 }
4384 Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO => {
4385 Some("RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO")
4386 }
4387 Self::IMAGE_VIEW_USAGE_CREATE_INFO => Some("IMAGE_VIEW_USAGE_CREATE_INFO"),
4388 Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO => {
4389 Some("PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO")
4390 }
4391 Self::RENDER_PASS_MULTIVIEW_CREATE_INFO => Some("RENDER_PASS_MULTIVIEW_CREATE_INFO"),
4392 Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES => Some("PHYSICAL_DEVICE_MULTIVIEW_FEATURES"),
4393 Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES => {
4394 Some("PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES")
4395 }
4396 Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES => {
4397 Some("PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES")
4398 }
4399 Self::PROTECTED_SUBMIT_INFO => Some("PROTECTED_SUBMIT_INFO"),
4400 Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES => {
4401 Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES")
4402 }
4403 Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES => {
4404 Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES")
4405 }
4406 Self::DEVICE_QUEUE_INFO_2 => Some("DEVICE_QUEUE_INFO_2"),
4407 Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO => {
4408 Some("SAMPLER_YCBCR_CONVERSION_CREATE_INFO")
4409 }
4410 Self::SAMPLER_YCBCR_CONVERSION_INFO => Some("SAMPLER_YCBCR_CONVERSION_INFO"),
4411 Self::BIND_IMAGE_PLANE_MEMORY_INFO => Some("BIND_IMAGE_PLANE_MEMORY_INFO"),
4412 Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO => {
4413 Some("IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO")
4414 }
4415 Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES => {
4416 Some("PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES")
4417 }
4418 Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES => {
4419 Some("SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES")
4420 }
4421 Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO => {
4422 Some("DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO")
4423 }
4424 Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO => {
4425 Some("PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO")
4426 }
4427 Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES => Some("EXTERNAL_IMAGE_FORMAT_PROPERTIES"),
4428 Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO => {
4429 Some("PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO")
4430 }
4431 Self::EXTERNAL_BUFFER_PROPERTIES => Some("EXTERNAL_BUFFER_PROPERTIES"),
4432 Self::PHYSICAL_DEVICE_ID_PROPERTIES => Some("PHYSICAL_DEVICE_ID_PROPERTIES"),
4433 Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO => Some("EXTERNAL_MEMORY_BUFFER_CREATE_INFO"),
4434 Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO => Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO"),
4435 Self::EXPORT_MEMORY_ALLOCATE_INFO => Some("EXPORT_MEMORY_ALLOCATE_INFO"),
4436 Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO => {
4437 Some("PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO")
4438 }
4439 Self::EXTERNAL_FENCE_PROPERTIES => Some("EXTERNAL_FENCE_PROPERTIES"),
4440 Self::EXPORT_FENCE_CREATE_INFO => Some("EXPORT_FENCE_CREATE_INFO"),
4441 Self::EXPORT_SEMAPHORE_CREATE_INFO => Some("EXPORT_SEMAPHORE_CREATE_INFO"),
4442 Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO => {
4443 Some("PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO")
4444 }
4445 Self::EXTERNAL_SEMAPHORE_PROPERTIES => Some("EXTERNAL_SEMAPHORE_PROPERTIES"),
4446 Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES => {
4447 Some("PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES")
4448 }
4449 Self::DESCRIPTOR_SET_LAYOUT_SUPPORT => Some("DESCRIPTOR_SET_LAYOUT_SUPPORT"),
4450 Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES => {
4451 Some("PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES")
4452 }
4453 Self::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES => {
4454 Some("PHYSICAL_DEVICE_VULKAN_1_1_FEATURES")
4455 }
4456 Self::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES => {
4457 Some("PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES")
4458 }
4459 Self::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES => {
4460 Some("PHYSICAL_DEVICE_VULKAN_1_2_FEATURES")
4461 }
4462 Self::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES => {
4463 Some("PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES")
4464 }
4465 Self::IMAGE_FORMAT_LIST_CREATE_INFO => Some("IMAGE_FORMAT_LIST_CREATE_INFO"),
4466 Self::ATTACHMENT_DESCRIPTION_2 => Some("ATTACHMENT_DESCRIPTION_2"),
4467 Self::ATTACHMENT_REFERENCE_2 => Some("ATTACHMENT_REFERENCE_2"),
4468 Self::SUBPASS_DESCRIPTION_2 => Some("SUBPASS_DESCRIPTION_2"),
4469 Self::SUBPASS_DEPENDENCY_2 => Some("SUBPASS_DEPENDENCY_2"),
4470 Self::RENDER_PASS_CREATE_INFO_2 => Some("RENDER_PASS_CREATE_INFO_2"),
4471 Self::SUBPASS_BEGIN_INFO => Some("SUBPASS_BEGIN_INFO"),
4472 Self::SUBPASS_END_INFO => Some("SUBPASS_END_INFO"),
4473 Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES => {
4474 Some("PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES")
4475 }
4476 Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES => Some("PHYSICAL_DEVICE_DRIVER_PROPERTIES"),
4477 Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES => {
4478 Some("PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES")
4479 }
4480 Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES => {
4481 Some("PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES")
4482 }
4483 Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES => {
4484 Some("PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES")
4485 }
4486 Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO => {
4487 Some("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO")
4488 }
4489 Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES => {
4490 Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES")
4491 }
4492 Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES => {
4493 Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES")
4494 }
4495 Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO => {
4496 Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO")
4497 }
4498 Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT => {
4499 Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT")
4500 }
4501 Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES => {
4502 Some("PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES")
4503 }
4504 Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE => {
4505 Some("SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE")
4506 }
4507 Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES => {
4508 Some("PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES")
4509 }
4510 Self::IMAGE_STENCIL_USAGE_CREATE_INFO => Some("IMAGE_STENCIL_USAGE_CREATE_INFO"),
4511 Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES => {
4512 Some("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES")
4513 }
4514 Self::SAMPLER_REDUCTION_MODE_CREATE_INFO => Some("SAMPLER_REDUCTION_MODE_CREATE_INFO"),
4515 Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES => {
4516 Some("PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES")
4517 }
4518 Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES => {
4519 Some("PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES")
4520 }
4521 Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO => {
4522 Some("FRAMEBUFFER_ATTACHMENTS_CREATE_INFO")
4523 }
4524 Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO => Some("FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"),
4525 Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO => Some("RENDER_PASS_ATTACHMENT_BEGIN_INFO"),
4526 Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES => {
4527 Some("PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES")
4528 }
4529 Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES => {
4530 Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES")
4531 }
4532 Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES => {
4533 Some("PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES")
4534 }
4535 Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT => {
4536 Some("ATTACHMENT_REFERENCE_STENCIL_LAYOUT")
4537 }
4538 Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT => {
4539 Some("ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT")
4540 }
4541 Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES => {
4542 Some("PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES")
4543 }
4544 Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES => {
4545 Some("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES")
4546 }
4547 Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES => {
4548 Some("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES")
4549 }
4550 Self::SEMAPHORE_TYPE_CREATE_INFO => Some("SEMAPHORE_TYPE_CREATE_INFO"),
4551 Self::TIMELINE_SEMAPHORE_SUBMIT_INFO => Some("TIMELINE_SEMAPHORE_SUBMIT_INFO"),
4552 Self::SEMAPHORE_WAIT_INFO => Some("SEMAPHORE_WAIT_INFO"),
4553 Self::SEMAPHORE_SIGNAL_INFO => Some("SEMAPHORE_SIGNAL_INFO"),
4554 Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES => {
4555 Some("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES")
4556 }
4557 Self::BUFFER_DEVICE_ADDRESS_INFO => Some("BUFFER_DEVICE_ADDRESS_INFO"),
4558 Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO => {
4559 Some("BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO")
4560 }
4561 Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO => {
4562 Some("MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO")
4563 }
4564 Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO => {
4565 Some("DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO")
4566 }
4567 _ => None,
4568 };
4569 if let Some(x) = name {
4570 f.write_str(x)
4571 } else {
4572 self.0.fmt(f)
4573 }
4574 }
4575 }
4576 impl fmt::Debug for SubgroupFeatureFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4577 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4578 const KNOWN: &[(Flags, &str)] = &[
4579 (SubgroupFeatureFlags::BASIC.0, "BASIC"),
4580 (SubgroupFeatureFlags::VOTE.0, "VOTE"),
4581 (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"),
4582 (SubgroupFeatureFlags::BALLOT.0, "BALLOT"),
4583 (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"),
4584 (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"),
4585 (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"),
4586 (SubgroupFeatureFlags::QUAD.0, "QUAD"),
4587 (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"),
4588 ];
4589 debug_flags(f, KNOWN, self.0)
4590 }
4591 }
4592 impl fmt::Debug for SubpassContents {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4593 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4594 let name = match *self {
4595 Self::INLINE => Some("INLINE"),
4596 Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"),
4597 _ => None,
4598 };
4599 if let Some(x) = name {
4600 f.write_str(x)
4601 } else {
4602 self.0.fmt(f)
4603 }
4604 }
4605 }
4606 impl fmt::Debug for SubpassDescriptionFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4607 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4608 const KNOWN: &[(Flags, &str)] = &[
4609 (
4610 SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0,
4611 "PER_VIEW_ATTRIBUTES_NVX",
4612 ),
4613 (
4614 SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0,
4615 "PER_VIEW_POSITION_X_ONLY_NVX",
4616 ),
4617 (
4618 SubpassDescriptionFlags::FRAGMENT_REGION_QCOM.0,
4619 "FRAGMENT_REGION_QCOM",
4620 ),
4621 (
4622 SubpassDescriptionFlags::SHADER_RESOLVE_QCOM.0,
4623 "SHADER_RESOLVE_QCOM",
4624 ),
4625 ];
4626 debug_flags(f, KNOWN, self.0)
4627 }
4628 }
4629 impl fmt::Debug for SurfaceCounterFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4630 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4631 const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")];
4632 debug_flags(f, KNOWN, self.0)
4633 }
4634 }
4635 impl fmt::Debug for SurfaceTransformFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4636 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4637 const KNOWN: &[(Flags, &str)] = &[
4638 (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"),
4639 (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"),
4640 (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"),
4641 (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"),
4642 (
4643 SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0,
4644 "HORIZONTAL_MIRROR",
4645 ),
4646 (
4647 SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0,
4648 "HORIZONTAL_MIRROR_ROTATE_90",
4649 ),
4650 (
4651 SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0,
4652 "HORIZONTAL_MIRROR_ROTATE_180",
4653 ),
4654 (
4655 SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0,
4656 "HORIZONTAL_MIRROR_ROTATE_270",
4657 ),
4658 (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"),
4659 ];
4660 debug_flags(f, KNOWN, self.0)
4661 }
4662 }
4663 impl fmt::Debug for SwapchainCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4664 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4665 const KNOWN: &[(Flags, &str)] = &[
4666 (
4667 SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0,
4668 "SPLIT_INSTANCE_BIND_REGIONS",
4669 ),
4670 (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"),
4671 (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"),
4672 ];
4673 debug_flags(f, KNOWN, self.0)
4674 }
4675 }
4676 impl fmt::Debug for SwapchainImageUsageFlagsANDROID {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4677 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4678 const KNOWN: &[(Flags, &str)] = &[(SwapchainImageUsageFlagsANDROID::SHARED.0, "SHARED")];
4679 debug_flags(f, KNOWN, self.0)
4680 }
4681 }
4682 impl fmt::Debug for SystemAllocationScope {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4683 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4684 let name = match *self {
4685 Self::COMMAND => Some("COMMAND"),
4686 Self::OBJECT => Some("OBJECT"),
4687 Self::CACHE => Some("CACHE"),
4688 Self::DEVICE => Some("DEVICE"),
4689 Self::INSTANCE => Some("INSTANCE"),
4690 _ => None,
4691 };
4692 if let Some(x) = name {
4693 f.write_str(x)
4694 } else {
4695 self.0.fmt(f)
4696 }
4697 }
4698 }
4699 impl fmt::Debug for TessellationDomainOrigin {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4700 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4701 let name = match *self {
4702 Self::UPPER_LEFT => Some("UPPER_LEFT"),
4703 Self::LOWER_LEFT => Some("LOWER_LEFT"),
4704 _ => None,
4705 };
4706 if let Some(x) = name {
4707 f.write_str(x)
4708 } else {
4709 self.0.fmt(f)
4710 }
4711 }
4712 }
4713 impl fmt::Debug for TimeDomainEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4714 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4715 let name = match *self {
4716 Self::DEVICE => Some("DEVICE"),
4717 Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"),
4718 Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"),
4719 Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"),
4720 _ => None,
4721 };
4722 if let Some(x) = name {
4723 f.write_str(x)
4724 } else {
4725 self.0.fmt(f)
4726 }
4727 }
4728 }
4729 impl fmt::Debug for ToolPurposeFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4730 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4731 const KNOWN: &[(Flags, &str)] = &[
4732 (ToolPurposeFlagsEXT::VALIDATION.0, "VALIDATION"),
4733 (ToolPurposeFlagsEXT::PROFILING.0, "PROFILING"),
4734 (ToolPurposeFlagsEXT::TRACING.0, "TRACING"),
4735 (
4736 ToolPurposeFlagsEXT::ADDITIONAL_FEATURES.0,
4737 "ADDITIONAL_FEATURES",
4738 ),
4739 (
4740 ToolPurposeFlagsEXT::MODIFYING_FEATURES.0,
4741 "MODIFYING_FEATURES",
4742 ),
4743 (ToolPurposeFlagsEXT::DEBUG_REPORTING.0, "DEBUG_REPORTING"),
4744 (ToolPurposeFlagsEXT::DEBUG_MARKERS.0, "DEBUG_MARKERS"),
4745 ];
4746 debug_flags(f, KNOWN, self.0)
4747 }
4748 }
4749 impl fmt::Debug for ValidationCacheCreateFlagsEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4750 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4751 const KNOWN: &[(Flags, &str)] = &[];
4752 debug_flags(f, KNOWN, self.0)
4753 }
4754 }
4755 impl fmt::Debug for ValidationCacheHeaderVersionEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4756 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4757 let name = match *self {
4758 Self::ONE => Some("ONE"),
4759 _ => None,
4760 };
4761 if let Some(x) = name {
4762 f.write_str(x)
4763 } else {
4764 self.0.fmt(f)
4765 }
4766 }
4767 }
4768 impl fmt::Debug for ValidationCheckEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4769 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4770 let name = match *self {
4771 Self::ALL => Some("ALL"),
4772 Self::SHADERS => Some("SHADERS"),
4773 _ => None,
4774 };
4775 if let Some(x) = name {
4776 f.write_str(x)
4777 } else {
4778 self.0.fmt(f)
4779 }
4780 }
4781 }
4782 impl fmt::Debug for ValidationFeatureDisableEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4783 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4784 let name = match *self {
4785 Self::ALL => Some("ALL"),
4786 Self::SHADERS => Some("SHADERS"),
4787 Self::THREAD_SAFETY => Some("THREAD_SAFETY"),
4788 Self::API_PARAMETERS => Some("API_PARAMETERS"),
4789 Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"),
4790 Self::CORE_CHECKS => Some("CORE_CHECKS"),
4791 Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"),
4792 _ => None,
4793 };
4794 if let Some(x) = name {
4795 f.write_str(x)
4796 } else {
4797 self.0.fmt(f)
4798 }
4799 }
4800 }
4801 impl fmt::Debug for ValidationFeatureEnableEXT {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4802 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4803 let name = match *self {
4804 Self::GPU_ASSISTED => Some("GPU_ASSISTED"),
4805 Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"),
4806 Self::BEST_PRACTICES => Some("BEST_PRACTICES"),
4807 Self::DEBUG_PRINTF => Some("DEBUG_PRINTF"),
4808 Self::SYNCHRONIZATION_VALIDATION => Some("SYNCHRONIZATION_VALIDATION"),
4809 _ => None,
4810 };
4811 if let Some(x) = name {
4812 f.write_str(x)
4813 } else {
4814 self.0.fmt(f)
4815 }
4816 }
4817 }
4818 impl fmt::Debug for VendorId {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4819 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4820 let name = match *self {
4821 Self::VIV => Some("VIV"),
4822 Self::VSI => Some("VSI"),
4823 Self::KAZAN => Some("KAZAN"),
4824 Self::CODEPLAY => Some("CODEPLAY"),
4825 Self::MESA => Some("MESA"),
4826 Self::POCL => Some("POCL"),
4827 _ => None,
4828 };
4829 if let Some(x) = name {
4830 f.write_str(x)
4831 } else {
4832 self.0.fmt(f)
4833 }
4834 }
4835 }
4836 impl fmt::Debug for VertexInputRate {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4837 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4838 let name = match *self {
4839 Self::VERTEX => Some("VERTEX"),
4840 Self::INSTANCE => Some("INSTANCE"),
4841 _ => None,
4842 };
4843 if let Some(x) = name {
4844 f.write_str(x)
4845 } else {
4846 self.0.fmt(f)
4847 }
4848 }
4849 }
4850 impl fmt::Debug for ViSurfaceCreateFlagsNN {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4851 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4852 const KNOWN: &[(Flags, &str)] = &[];
4853 debug_flags(f, KNOWN, self.0)
4854 }
4855 }
4856 impl fmt::Debug for ViewportCoordinateSwizzleNV {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4857 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4858 let name = match *self {
4859 Self::POSITIVE_X => Some("POSITIVE_X"),
4860 Self::NEGATIVE_X => Some("NEGATIVE_X"),
4861 Self::POSITIVE_Y => Some("POSITIVE_Y"),
4862 Self::NEGATIVE_Y => Some("NEGATIVE_Y"),
4863 Self::POSITIVE_Z => Some("POSITIVE_Z"),
4864 Self::NEGATIVE_Z => Some("NEGATIVE_Z"),
4865 Self::POSITIVE_W => Some("POSITIVE_W"),
4866 Self::NEGATIVE_W => Some("NEGATIVE_W"),
4867 _ => None,
4868 };
4869 if let Some(x) = name {
4870 f.write_str(x)
4871 } else {
4872 self.0.fmt(f)
4873 }
4874 }
4875 }
4876 impl fmt::Debug for WaylandSurfaceCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4877 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4878 const KNOWN: &[(Flags, &str)] = &[];
4879 debug_flags(f, KNOWN, self.0)
4880 }
4881 }
4882 impl fmt::Debug for Win32SurfaceCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4883 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4884 const KNOWN: &[(Flags, &str)] = &[];
4885 debug_flags(f, KNOWN, self.0)
4886 }
4887 }
4888 impl fmt::Debug for XcbSurfaceCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4889 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4890 const KNOWN: &[(Flags, &str)] = &[];
4891 debug_flags(f, KNOWN, self.0)
4892 }
4893 }
4894 impl fmt::Debug for XlibSurfaceCreateFlagsKHR {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4895 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4896 const KNOWN: &[(Flags, &str)] = &[];
4897 debug_flags(f, KNOWN, self.0)
4898 }
4899 }
4900