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