blob: d06d7dd6366407bd7aebb489186ba29e3826b647 [file] [log] [blame]
/*
* Copyright (c) 2019 The Khronos Group Inc.
* Copyright (c) 2019 Valve Corporation
* Copyright (c) 2019 LunarG, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Author: Charles Giessen <charles@lunarg.com>
*
*/
/*
* This file is generated from the Khronos Vulkan XML API Registry.
*/
#include "vulkaninfo.h"
#include "outputprinter.h"
void DumpVkConformanceVersion(Printer &p, std::string name, VkConformanceVersion &c, int width = 0) {
p.PrintKeyString("conformanceVersion", std::to_string(c.major)+ "." + std::to_string(c.minor) + "." + std::to_string(c.subminor) + "."
+ std::to_string(c.patch), width);
}
template <typename T>
std::string to_hex_str(T i) {
std::stringstream stream;
stream << "0x" << std::setfill('0') << std::setw(sizeof(T)) << std::hex << i;
return stream.str();
}
template <typename T>
std::string to_hex_str(Printer &p, T i) {
if (p.Type() == OutputType::json)
return std::to_string(i);
else if (p.Type() == OutputType::vkconfig_output)
return std::string("\"") + to_hex_str(i) + std::string("\"");
else
return to_hex_str(i);
}
static const char *VkColorSpaceKHRString(VkColorSpaceKHR value) {
switch (value) {
case (0): return "COLOR_SPACE_SRGB_NONLINEAR_KHR";
case (1000104001): return "COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
case (1000104002): return "COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
case (1000104003): return "COLOR_SPACE_DISPLAY_P3_LINEAR_EXT";
case (1000104004): return "COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
case (1000104005): return "COLOR_SPACE_BT709_LINEAR_EXT";
case (1000104006): return "COLOR_SPACE_BT709_NONLINEAR_EXT";
case (1000104007): return "COLOR_SPACE_BT2020_LINEAR_EXT";
case (1000104008): return "COLOR_SPACE_HDR10_ST2084_EXT";
case (1000104009): return "COLOR_SPACE_DOLBYVISION_EXT";
case (1000104010): return "COLOR_SPACE_HDR10_HLG_EXT";
case (1000104011): return "COLOR_SPACE_ADOBERGB_LINEAR_EXT";
case (1000104012): return "COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
case (1000104013): return "COLOR_SPACE_PASS_THROUGH_EXT";
case (1000104014): return "COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT";
case (1000213000): return "COLOR_SPACE_DISPLAY_NATIVE_AMD";
default: return "UNKNOWN_VkColorSpaceKHR";
}
}
void DumpVkColorSpaceKHR(Printer &p, std::string name, VkColorSpaceKHR value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkColorSpaceKHRString(value), width);
}
}
static const char *VkDriverIdString(VkDriverId value) {
switch (value) {
case (1): return "DRIVER_ID_AMD_PROPRIETARY";
case (2): return "DRIVER_ID_AMD_OPEN_SOURCE";
case (3): return "DRIVER_ID_MESA_RADV";
case (4): return "DRIVER_ID_NVIDIA_PROPRIETARY";
case (5): return "DRIVER_ID_INTEL_PROPRIETARY_WINDOWS";
case (6): return "DRIVER_ID_INTEL_OPEN_SOURCE_MESA";
case (7): return "DRIVER_ID_IMAGINATION_PROPRIETARY";
case (8): return "DRIVER_ID_QUALCOMM_PROPRIETARY";
case (9): return "DRIVER_ID_ARM_PROPRIETARY";
case (10): return "DRIVER_ID_GOOGLE_SWIFTSHADER";
case (11): return "DRIVER_ID_GGP_PROPRIETARY";
case (12): return "DRIVER_ID_BROADCOM_PROPRIETARY";
case (13): return "DRIVER_ID_MESA_LLVMPIPE";
default: return "UNKNOWN_VkDriverId";
}
}
void DumpVkDriverId(Printer &p, std::string name, VkDriverId value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkDriverIdString(value), width);
}
}
static const char *VkFormatString(VkFormat value) {
switch (value) {
case (0): return "FORMAT_UNDEFINED";
case (1): return "FORMAT_R4G4_UNORM_PACK8";
case (2): return "FORMAT_R4G4B4A4_UNORM_PACK16";
case (3): return "FORMAT_B4G4R4A4_UNORM_PACK16";
case (4): return "FORMAT_R5G6B5_UNORM_PACK16";
case (5): return "FORMAT_B5G6R5_UNORM_PACK16";
case (6): return "FORMAT_R5G5B5A1_UNORM_PACK16";
case (7): return "FORMAT_B5G5R5A1_UNORM_PACK16";
case (8): return "FORMAT_A1R5G5B5_UNORM_PACK16";
case (9): return "FORMAT_R8_UNORM";
case (10): return "FORMAT_R8_SNORM";
case (11): return "FORMAT_R8_USCALED";
case (12): return "FORMAT_R8_SSCALED";
case (13): return "FORMAT_R8_UINT";
case (14): return "FORMAT_R8_SINT";
case (15): return "FORMAT_R8_SRGB";
case (16): return "FORMAT_R8G8_UNORM";
case (17): return "FORMAT_R8G8_SNORM";
case (18): return "FORMAT_R8G8_USCALED";
case (19): return "FORMAT_R8G8_SSCALED";
case (20): return "FORMAT_R8G8_UINT";
case (21): return "FORMAT_R8G8_SINT";
case (22): return "FORMAT_R8G8_SRGB";
case (23): return "FORMAT_R8G8B8_UNORM";
case (24): return "FORMAT_R8G8B8_SNORM";
case (25): return "FORMAT_R8G8B8_USCALED";
case (26): return "FORMAT_R8G8B8_SSCALED";
case (27): return "FORMAT_R8G8B8_UINT";
case (28): return "FORMAT_R8G8B8_SINT";
case (29): return "FORMAT_R8G8B8_SRGB";
case (30): return "FORMAT_B8G8R8_UNORM";
case (31): return "FORMAT_B8G8R8_SNORM";
case (32): return "FORMAT_B8G8R8_USCALED";
case (33): return "FORMAT_B8G8R8_SSCALED";
case (34): return "FORMAT_B8G8R8_UINT";
case (35): return "FORMAT_B8G8R8_SINT";
case (36): return "FORMAT_B8G8R8_SRGB";
case (37): return "FORMAT_R8G8B8A8_UNORM";
case (38): return "FORMAT_R8G8B8A8_SNORM";
case (39): return "FORMAT_R8G8B8A8_USCALED";
case (40): return "FORMAT_R8G8B8A8_SSCALED";
case (41): return "FORMAT_R8G8B8A8_UINT";
case (42): return "FORMAT_R8G8B8A8_SINT";
case (43): return "FORMAT_R8G8B8A8_SRGB";
case (44): return "FORMAT_B8G8R8A8_UNORM";
case (45): return "FORMAT_B8G8R8A8_SNORM";
case (46): return "FORMAT_B8G8R8A8_USCALED";
case (47): return "FORMAT_B8G8R8A8_SSCALED";
case (48): return "FORMAT_B8G8R8A8_UINT";
case (49): return "FORMAT_B8G8R8A8_SINT";
case (50): return "FORMAT_B8G8R8A8_SRGB";
case (51): return "FORMAT_A8B8G8R8_UNORM_PACK32";
case (52): return "FORMAT_A8B8G8R8_SNORM_PACK32";
case (53): return "FORMAT_A8B8G8R8_USCALED_PACK32";
case (54): return "FORMAT_A8B8G8R8_SSCALED_PACK32";
case (55): return "FORMAT_A8B8G8R8_UINT_PACK32";
case (56): return "FORMAT_A8B8G8R8_SINT_PACK32";
case (57): return "FORMAT_A8B8G8R8_SRGB_PACK32";
case (58): return "FORMAT_A2R10G10B10_UNORM_PACK32";
case (59): return "FORMAT_A2R10G10B10_SNORM_PACK32";
case (60): return "FORMAT_A2R10G10B10_USCALED_PACK32";
case (61): return "FORMAT_A2R10G10B10_SSCALED_PACK32";
case (62): return "FORMAT_A2R10G10B10_UINT_PACK32";
case (63): return "FORMAT_A2R10G10B10_SINT_PACK32";
case (64): return "FORMAT_A2B10G10R10_UNORM_PACK32";
case (65): return "FORMAT_A2B10G10R10_SNORM_PACK32";
case (66): return "FORMAT_A2B10G10R10_USCALED_PACK32";
case (67): return "FORMAT_A2B10G10R10_SSCALED_PACK32";
case (68): return "FORMAT_A2B10G10R10_UINT_PACK32";
case (69): return "FORMAT_A2B10G10R10_SINT_PACK32";
case (70): return "FORMAT_R16_UNORM";
case (71): return "FORMAT_R16_SNORM";
case (72): return "FORMAT_R16_USCALED";
case (73): return "FORMAT_R16_SSCALED";
case (74): return "FORMAT_R16_UINT";
case (75): return "FORMAT_R16_SINT";
case (76): return "FORMAT_R16_SFLOAT";
case (77): return "FORMAT_R16G16_UNORM";
case (78): return "FORMAT_R16G16_SNORM";
case (79): return "FORMAT_R16G16_USCALED";
case (80): return "FORMAT_R16G16_SSCALED";
case (81): return "FORMAT_R16G16_UINT";
case (82): return "FORMAT_R16G16_SINT";
case (83): return "FORMAT_R16G16_SFLOAT";
case (84): return "FORMAT_R16G16B16_UNORM";
case (85): return "FORMAT_R16G16B16_SNORM";
case (86): return "FORMAT_R16G16B16_USCALED";
case (87): return "FORMAT_R16G16B16_SSCALED";
case (88): return "FORMAT_R16G16B16_UINT";
case (89): return "FORMAT_R16G16B16_SINT";
case (90): return "FORMAT_R16G16B16_SFLOAT";
case (91): return "FORMAT_R16G16B16A16_UNORM";
case (92): return "FORMAT_R16G16B16A16_SNORM";
case (93): return "FORMAT_R16G16B16A16_USCALED";
case (94): return "FORMAT_R16G16B16A16_SSCALED";
case (95): return "FORMAT_R16G16B16A16_UINT";
case (96): return "FORMAT_R16G16B16A16_SINT";
case (97): return "FORMAT_R16G16B16A16_SFLOAT";
case (98): return "FORMAT_R32_UINT";
case (99): return "FORMAT_R32_SINT";
case (100): return "FORMAT_R32_SFLOAT";
case (101): return "FORMAT_R32G32_UINT";
case (102): return "FORMAT_R32G32_SINT";
case (103): return "FORMAT_R32G32_SFLOAT";
case (104): return "FORMAT_R32G32B32_UINT";
case (105): return "FORMAT_R32G32B32_SINT";
case (106): return "FORMAT_R32G32B32_SFLOAT";
case (107): return "FORMAT_R32G32B32A32_UINT";
case (108): return "FORMAT_R32G32B32A32_SINT";
case (109): return "FORMAT_R32G32B32A32_SFLOAT";
case (110): return "FORMAT_R64_UINT";
case (111): return "FORMAT_R64_SINT";
case (112): return "FORMAT_R64_SFLOAT";
case (113): return "FORMAT_R64G64_UINT";
case (114): return "FORMAT_R64G64_SINT";
case (115): return "FORMAT_R64G64_SFLOAT";
case (116): return "FORMAT_R64G64B64_UINT";
case (117): return "FORMAT_R64G64B64_SINT";
case (118): return "FORMAT_R64G64B64_SFLOAT";
case (119): return "FORMAT_R64G64B64A64_UINT";
case (120): return "FORMAT_R64G64B64A64_SINT";
case (121): return "FORMAT_R64G64B64A64_SFLOAT";
case (122): return "FORMAT_B10G11R11_UFLOAT_PACK32";
case (123): return "FORMAT_E5B9G9R9_UFLOAT_PACK32";
case (124): return "FORMAT_D16_UNORM";
case (125): return "FORMAT_X8_D24_UNORM_PACK32";
case (126): return "FORMAT_D32_SFLOAT";
case (127): return "FORMAT_S8_UINT";
case (128): return "FORMAT_D16_UNORM_S8_UINT";
case (129): return "FORMAT_D24_UNORM_S8_UINT";
case (130): return "FORMAT_D32_SFLOAT_S8_UINT";
case (131): return "FORMAT_BC1_RGB_UNORM_BLOCK";
case (132): return "FORMAT_BC1_RGB_SRGB_BLOCK";
case (133): return "FORMAT_BC1_RGBA_UNORM_BLOCK";
case (134): return "FORMAT_BC1_RGBA_SRGB_BLOCK";
case (135): return "FORMAT_BC2_UNORM_BLOCK";
case (136): return "FORMAT_BC2_SRGB_BLOCK";
case (137): return "FORMAT_BC3_UNORM_BLOCK";
case (138): return "FORMAT_BC3_SRGB_BLOCK";
case (139): return "FORMAT_BC4_UNORM_BLOCK";
case (140): return "FORMAT_BC4_SNORM_BLOCK";
case (141): return "FORMAT_BC5_UNORM_BLOCK";
case (142): return "FORMAT_BC5_SNORM_BLOCK";
case (143): return "FORMAT_BC6H_UFLOAT_BLOCK";
case (144): return "FORMAT_BC6H_SFLOAT_BLOCK";
case (145): return "FORMAT_BC7_UNORM_BLOCK";
case (146): return "FORMAT_BC7_SRGB_BLOCK";
case (147): return "FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
case (148): return "FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
case (149): return "FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
case (150): return "FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
case (151): return "FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
case (152): return "FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
case (153): return "FORMAT_EAC_R11_UNORM_BLOCK";
case (154): return "FORMAT_EAC_R11_SNORM_BLOCK";
case (155): return "FORMAT_EAC_R11G11_UNORM_BLOCK";
case (156): return "FORMAT_EAC_R11G11_SNORM_BLOCK";
case (157): return "FORMAT_ASTC_4x4_UNORM_BLOCK";
case (158): return "FORMAT_ASTC_4x4_SRGB_BLOCK";
case (159): return "FORMAT_ASTC_5x4_UNORM_BLOCK";
case (160): return "FORMAT_ASTC_5x4_SRGB_BLOCK";
case (161): return "FORMAT_ASTC_5x5_UNORM_BLOCK";
case (162): return "FORMAT_ASTC_5x5_SRGB_BLOCK";
case (163): return "FORMAT_ASTC_6x5_UNORM_BLOCK";
case (164): return "FORMAT_ASTC_6x5_SRGB_BLOCK";
case (165): return "FORMAT_ASTC_6x6_UNORM_BLOCK";
case (166): return "FORMAT_ASTC_6x6_SRGB_BLOCK";
case (167): return "FORMAT_ASTC_8x5_UNORM_BLOCK";
case (168): return "FORMAT_ASTC_8x5_SRGB_BLOCK";
case (169): return "FORMAT_ASTC_8x6_UNORM_BLOCK";
case (170): return "FORMAT_ASTC_8x6_SRGB_BLOCK";
case (171): return "FORMAT_ASTC_8x8_UNORM_BLOCK";
case (172): return "FORMAT_ASTC_8x8_SRGB_BLOCK";
case (173): return "FORMAT_ASTC_10x5_UNORM_BLOCK";
case (174): return "FORMAT_ASTC_10x5_SRGB_BLOCK";
case (175): return "FORMAT_ASTC_10x6_UNORM_BLOCK";
case (176): return "FORMAT_ASTC_10x6_SRGB_BLOCK";
case (177): return "FORMAT_ASTC_10x8_UNORM_BLOCK";
case (178): return "FORMAT_ASTC_10x8_SRGB_BLOCK";
case (179): return "FORMAT_ASTC_10x10_UNORM_BLOCK";
case (180): return "FORMAT_ASTC_10x10_SRGB_BLOCK";
case (181): return "FORMAT_ASTC_12x10_UNORM_BLOCK";
case (182): return "FORMAT_ASTC_12x10_SRGB_BLOCK";
case (183): return "FORMAT_ASTC_12x12_UNORM_BLOCK";
case (184): return "FORMAT_ASTC_12x12_SRGB_BLOCK";
case (1000156000): return "FORMAT_G8B8G8R8_422_UNORM";
case (1000156001): return "FORMAT_B8G8R8G8_422_UNORM";
case (1000156002): return "FORMAT_G8_B8_R8_3PLANE_420_UNORM";
case (1000156003): return "FORMAT_G8_B8R8_2PLANE_420_UNORM";
case (1000156004): return "FORMAT_G8_B8_R8_3PLANE_422_UNORM";
case (1000156005): return "FORMAT_G8_B8R8_2PLANE_422_UNORM";
case (1000156006): return "FORMAT_G8_B8_R8_3PLANE_444_UNORM";
case (1000156007): return "FORMAT_R10X6_UNORM_PACK16";
case (1000156008): return "FORMAT_R10X6G10X6_UNORM_2PACK16";
case (1000156009): return "FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16";
case (1000156010): return "FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16";
case (1000156011): return "FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16";
case (1000156012): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16";
case (1000156013): return "FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16";
case (1000156014): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16";
case (1000156015): return "FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16";
case (1000156016): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16";
case (1000156017): return "FORMAT_R12X4_UNORM_PACK16";
case (1000156018): return "FORMAT_R12X4G12X4_UNORM_2PACK16";
case (1000156019): return "FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16";
case (1000156020): return "FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16";
case (1000156021): return "FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16";
case (1000156022): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16";
case (1000156023): return "FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16";
case (1000156024): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16";
case (1000156025): return "FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16";
case (1000156026): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16";
case (1000156027): return "FORMAT_G16B16G16R16_422_UNORM";
case (1000156028): return "FORMAT_B16G16R16G16_422_UNORM";
case (1000156029): return "FORMAT_G16_B16_R16_3PLANE_420_UNORM";
case (1000156030): return "FORMAT_G16_B16R16_2PLANE_420_UNORM";
case (1000156031): return "FORMAT_G16_B16_R16_3PLANE_422_UNORM";
case (1000156032): return "FORMAT_G16_B16R16_2PLANE_422_UNORM";
case (1000156033): return "FORMAT_G16_B16_R16_3PLANE_444_UNORM";
case (1000054000): return "FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
case (1000054001): return "FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG";
case (1000054002): return "FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG";
case (1000054003): return "FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG";
case (1000054004): return "FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG";
case (1000054005): return "FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG";
case (1000054006): return "FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
case (1000054007): return "FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
case (1000066000): return "FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT";
case (1000066001): return "FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT";
case (1000066002): return "FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT";
case (1000066003): return "FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT";
case (1000066004): return "FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT";
case (1000066005): return "FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT";
case (1000066006): return "FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT";
case (1000066007): return "FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT";
case (1000066008): return "FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT";
case (1000066009): return "FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT";
case (1000066010): return "FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT";
case (1000066011): return "FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT";
case (1000066012): return "FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT";
case (1000066013): return "FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT";
default: return "UNKNOWN_VkFormat";
}
}
void DumpVkFormat(Printer &p, std::string name, VkFormat value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkFormatString(value), width);
}
}
static const char *VkImageTilingString(VkImageTiling value) {
switch (value) {
case (0): return "IMAGE_TILING_OPTIMAL";
case (1): return "IMAGE_TILING_LINEAR";
case (1000158000): return "IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT";
default: return "UNKNOWN_VkImageTiling";
}
}
void DumpVkImageTiling(Printer &p, std::string name, VkImageTiling value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkImageTilingString(value), width);
}
}
static const char *VkPhysicalDeviceTypeString(VkPhysicalDeviceType value) {
switch (value) {
case (0): return "PHYSICAL_DEVICE_TYPE_OTHER";
case (1): return "PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
case (2): return "PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
case (3): return "PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
case (4): return "PHYSICAL_DEVICE_TYPE_CPU";
default: return "UNKNOWN_VkPhysicalDeviceType";
}
}
void DumpVkPhysicalDeviceType(Printer &p, std::string name, VkPhysicalDeviceType value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkPhysicalDeviceTypeString(value), width);
}
}
static const char *VkPointClippingBehaviorString(VkPointClippingBehavior value) {
switch (value) {
case (0): return "POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
case (1): return "POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
default: return "UNKNOWN_VkPointClippingBehavior";
}
}
void DumpVkPointClippingBehavior(Printer &p, std::string name, VkPointClippingBehavior value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkPointClippingBehaviorString(value), width);
}
}
static const char *VkPresentModeKHRString(VkPresentModeKHR value) {
switch (value) {
case (0): return "PRESENT_MODE_IMMEDIATE_KHR";
case (1): return "PRESENT_MODE_MAILBOX_KHR";
case (2): return "PRESENT_MODE_FIFO_KHR";
case (3): return "PRESENT_MODE_FIFO_RELAXED_KHR";
case (1000111000): return "PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
case (1000111001): return "PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
default: return "UNKNOWN_VkPresentModeKHR";
}
}
void DumpVkPresentModeKHR(Printer &p, std::string name, VkPresentModeKHR value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkPresentModeKHRString(value), width);
}
}
static const char *VkResultString(VkResult value) {
switch (value) {
case (0): return "SUCCESS";
case (1): return "NOT_READY";
case (2): return "TIMEOUT";
case (3): return "EVENT_SET";
case (4): return "EVENT_RESET";
case (5): return "INCOMPLETE";
case (-1): return "ERROR_OUT_OF_HOST_MEMORY";
case (-2): return "ERROR_OUT_OF_DEVICE_MEMORY";
case (-3): return "ERROR_INITIALIZATION_FAILED";
case (-4): return "ERROR_DEVICE_LOST";
case (-5): return "ERROR_MEMORY_MAP_FAILED";
case (-6): return "ERROR_LAYER_NOT_PRESENT";
case (-7): return "ERROR_EXTENSION_NOT_PRESENT";
case (-8): return "ERROR_FEATURE_NOT_PRESENT";
case (-9): return "ERROR_INCOMPATIBLE_DRIVER";
case (-10): return "ERROR_TOO_MANY_OBJECTS";
case (-11): return "ERROR_FORMAT_NOT_SUPPORTED";
case (-12): return "ERROR_FRAGMENTED_POOL";
case (-13): return "ERROR_UNKNOWN";
case (-1000069000): return "ERROR_OUT_OF_POOL_MEMORY";
case (-1000072003): return "ERROR_INVALID_EXTERNAL_HANDLE";
case (-1000161000): return "ERROR_FRAGMENTATION";
case (-1000257000): return "ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
case (-1000000000): return "ERROR_SURFACE_LOST_KHR";
case (-1000000001): return "ERROR_NATIVE_WINDOW_IN_USE_KHR";
case (1000001003): return "SUBOPTIMAL_KHR";
case (-1000001004): return "ERROR_OUT_OF_DATE_KHR";
case (-1000003001): return "ERROR_INCOMPATIBLE_DISPLAY_KHR";
case (-1000011001): return "ERROR_VALIDATION_FAILED_EXT";
case (-1000012000): return "ERROR_INVALID_SHADER_NV";
case (-1000150000): return "ERROR_INCOMPATIBLE_VERSION_KHR";
case (-1000158000): return "ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
case (-1000174001): return "ERROR_NOT_PERMITTED_EXT";
case (-1000255000): return "ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
case (1000268000): return "THREAD_IDLE_KHR";
case (1000268001): return "THREAD_DONE_KHR";
case (1000268002): return "OPERATION_DEFERRED_KHR";
case (1000268003): return "OPERATION_NOT_DEFERRED_KHR";
case (1000297000): return "PIPELINE_COMPILE_REQUIRED_EXT";
default: return "UNKNOWN_VkResult";
}
}
void DumpVkResult(Printer &p, std::string name, VkResult value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkResultString(value), width);
}
}
static const char *VkShaderFloatControlsIndependenceString(VkShaderFloatControlsIndependence value) {
switch (value) {
case (0): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY";
case (1): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL";
case (2): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE";
default: return "UNKNOWN_VkShaderFloatControlsIndependence";
}
}
void DumpVkShaderFloatControlsIndependence(Printer &p, std::string name, VkShaderFloatControlsIndependence value, int width = 0) {
if (p.Type() == OutputType::json) {
p.PrintKeyValue(name, value, width);
} else {
p.PrintKeyString(name, VkShaderFloatControlsIndependenceString(value), width);
}
}
std::vector<const char *>VkCompositeAlphaFlagBitsKHRGetStrings(VkCompositeAlphaFlagBitsKHR value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("COMPOSITE_ALPHA_OPAQUE_BIT_KHR");
if (0x2 & value) strings.push_back("COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR");
if (0x4 & value) strings.push_back("COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR");
if (0x8 & value) strings.push_back("COMPOSITE_ALPHA_INHERIT_BIT_KHR");
return strings;
}
void DumpVkCompositeAlphaFlagsKHR(Printer &p, std::string name, VkCompositeAlphaFlagsKHR value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(static_cast<VkCompositeAlphaFlagBitsKHR>(value));
if (static_cast<VkCompositeAlphaFlagBitsKHR>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkCompositeAlphaFlagBitsKHR(Printer &p, std::string name, VkCompositeAlphaFlagBitsKHR value, int width = 0) {
auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkDeviceGroupPresentModeFlagBitsKHRGetStrings(VkDeviceGroupPresentModeFlagBitsKHR value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR");
if (0x2 & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR");
if (0x4 & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR");
if (0x8 & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR");
return strings;
}
void DumpVkDeviceGroupPresentModeFlagsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagsKHR value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value));
if (static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkDeviceGroupPresentModeFlagBitsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagBitsKHR value, int width = 0) {
auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkFormatFeatureFlagBitsGetStrings(VkFormatFeatureFlagBits value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_BIT");
if (0x2 & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_BIT");
if (0x4 & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT");
if (0x8 & value) strings.push_back("FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT");
if (0x10 & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT");
if (0x20 & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT");
if (0x40 & value) strings.push_back("FORMAT_FEATURE_VERTEX_BUFFER_BIT");
if (0x80 & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BIT");
if (0x100 & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT");
if (0x200 & value) strings.push_back("FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT");
if (0x400 & value) strings.push_back("FORMAT_FEATURE_BLIT_SRC_BIT");
if (0x800 & value) strings.push_back("FORMAT_FEATURE_BLIT_DST_BIT");
if (0x1000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT");
if (0x4000 & value) strings.push_back("FORMAT_FEATURE_TRANSFER_SRC_BIT");
if (0x8000 & value) strings.push_back("FORMAT_FEATURE_TRANSFER_DST_BIT");
if (0x20000 & value) strings.push_back("FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT");
if (0x40000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT");
if (0x80000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT");
if (0x100000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT");
if (0x200000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT");
if (0x400000 & value) strings.push_back("FORMAT_FEATURE_DISJOINT_BIT");
if (0x800000 & value) strings.push_back("FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT");
if (0x10000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT");
if (0x2000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG");
if (0x20000000 & value) strings.push_back("FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR");
if (0x1000000 & value) strings.push_back("FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT");
return strings;
}
void DumpVkFormatFeatureFlags(Printer &p, std::string name, VkFormatFeatureFlags value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkFormatFeatureFlagBitsGetStrings(static_cast<VkFormatFeatureFlagBits>(value));
if (static_cast<VkFormatFeatureFlagBits>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkFormatFeatureFlagBits(Printer &p, std::string name, VkFormatFeatureFlagBits value, int width = 0) {
auto strings = VkFormatFeatureFlagBitsGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkImageUsageFlagBitsGetStrings(VkImageUsageFlagBits value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("IMAGE_USAGE_TRANSFER_SRC_BIT");
if (0x2 & value) strings.push_back("IMAGE_USAGE_TRANSFER_DST_BIT");
if (0x4 & value) strings.push_back("IMAGE_USAGE_SAMPLED_BIT");
if (0x8 & value) strings.push_back("IMAGE_USAGE_STORAGE_BIT");
if (0x10 & value) strings.push_back("IMAGE_USAGE_COLOR_ATTACHMENT_BIT");
if (0x20 & value) strings.push_back("IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT");
if (0x40 & value) strings.push_back("IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
if (0x80 & value) strings.push_back("IMAGE_USAGE_INPUT_ATTACHMENT_BIT");
if (0x100 & value) strings.push_back("IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV");
if (0x200 & value) strings.push_back("IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT");
return strings;
}
void DumpVkImageUsageFlags(Printer &p, std::string name, VkImageUsageFlags value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkImageUsageFlagBitsGetStrings(static_cast<VkImageUsageFlagBits>(value));
if (static_cast<VkImageUsageFlagBits>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkImageUsageFlagBits(Printer &p, std::string name, VkImageUsageFlagBits value, int width = 0) {
auto strings = VkImageUsageFlagBitsGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkMemoryHeapFlagBitsGetStrings(VkMemoryHeapFlagBits value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("MEMORY_HEAP_DEVICE_LOCAL_BIT");
if (0x2 & value) strings.push_back("MEMORY_HEAP_MULTI_INSTANCE_BIT");
return strings;
}
void DumpVkMemoryHeapFlags(Printer &p, std::string name, VkMemoryHeapFlags value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkMemoryHeapFlagBitsGetStrings(static_cast<VkMemoryHeapFlagBits>(value));
if (static_cast<VkMemoryHeapFlagBits>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkMemoryHeapFlagBits(Printer &p, std::string name, VkMemoryHeapFlagBits value, int width = 0) {
auto strings = VkMemoryHeapFlagBitsGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkMemoryPropertyFlagBitsGetStrings(VkMemoryPropertyFlagBits value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("MEMORY_PROPERTY_DEVICE_LOCAL_BIT");
if (0x2 & value) strings.push_back("MEMORY_PROPERTY_HOST_VISIBLE_BIT");
if (0x4 & value) strings.push_back("MEMORY_PROPERTY_HOST_COHERENT_BIT");
if (0x8 & value) strings.push_back("MEMORY_PROPERTY_HOST_CACHED_BIT");
if (0x10 & value) strings.push_back("MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT");
if (0x20 & value) strings.push_back("MEMORY_PROPERTY_PROTECTED_BIT");
if (0x40 & value) strings.push_back("MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD");
if (0x80 & value) strings.push_back("MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD");
return strings;
}
void DumpVkMemoryPropertyFlags(Printer &p, std::string name, VkMemoryPropertyFlags value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkMemoryPropertyFlagBitsGetStrings(static_cast<VkMemoryPropertyFlagBits>(value));
if (static_cast<VkMemoryPropertyFlagBits>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkMemoryPropertyFlagBits(Printer &p, std::string name, VkMemoryPropertyFlagBits value, int width = 0) {
auto strings = VkMemoryPropertyFlagBitsGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::string VkQueueFlagsString(VkQueueFlags value, int width = 0) {
std::string out;
bool is_first = true;
if (1 & value) {
if (is_first) { is_first = false; } else { out += " | "; }
out += "QUEUE_GRAPHICS";
}
if (2 & value) {
if (is_first) { is_first = false; } else { out += " | "; }
out += "QUEUE_COMPUTE";
}
if (4 & value) {
if (is_first) { is_first = false; } else { out += " | "; }
out += "QUEUE_TRANSFER";
}
if (8 & value) {
if (is_first) { is_first = false; } else { out += " | "; }
out += "QUEUE_SPARSE_BINDING";
}
if (16 & value) {
if (is_first) { is_first = false; } else { out += " | "; }
out += "QUEUE_PROTECTED";
}
return out;
}
std::vector<const char *>VkResolveModeFlagBitsGetStrings(VkResolveModeFlagBits value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0 & value) strings.push_back("RESOLVE_MODE_NONE");
if (0x1 & value) strings.push_back("RESOLVE_MODE_SAMPLE_ZERO_BIT");
if (0x2 & value) strings.push_back("RESOLVE_MODE_AVERAGE_BIT");
if (0x4 & value) strings.push_back("RESOLVE_MODE_MIN_BIT");
if (0x8 & value) strings.push_back("RESOLVE_MODE_MAX_BIT");
return strings;
}
void DumpVkResolveModeFlags(Printer &p, std::string name, VkResolveModeFlags value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkResolveModeFlagBitsGetStrings(static_cast<VkResolveModeFlagBits>(value));
if (static_cast<VkResolveModeFlagBits>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkResolveModeFlagBits(Printer &p, std::string name, VkResolveModeFlagBits value, int width = 0) {
auto strings = VkResolveModeFlagBitsGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkSampleCountFlagBitsGetStrings(VkSampleCountFlagBits value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("SAMPLE_COUNT_1_BIT");
if (0x2 & value) strings.push_back("SAMPLE_COUNT_2_BIT");
if (0x4 & value) strings.push_back("SAMPLE_COUNT_4_BIT");
if (0x8 & value) strings.push_back("SAMPLE_COUNT_8_BIT");
if (0x10 & value) strings.push_back("SAMPLE_COUNT_16_BIT");
if (0x20 & value) strings.push_back("SAMPLE_COUNT_32_BIT");
if (0x40 & value) strings.push_back("SAMPLE_COUNT_64_BIT");
return strings;
}
void DumpVkSampleCountFlags(Printer &p, std::string name, VkSampleCountFlags value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkSampleCountFlagBitsGetStrings(static_cast<VkSampleCountFlagBits>(value));
if (static_cast<VkSampleCountFlagBits>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkSampleCountFlagBits(Printer &p, std::string name, VkSampleCountFlagBits value, int width = 0) {
auto strings = VkSampleCountFlagBitsGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkShaderStageFlagBitsGetStrings(VkShaderStageFlagBits value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("SHADER_STAGE_VERTEX_BIT");
if (0x2 & value) strings.push_back("SHADER_STAGE_TESSELLATION_CONTROL_BIT");
if (0x4 & value) strings.push_back("SHADER_STAGE_TESSELLATION_EVALUATION_BIT");
if (0x8 & value) strings.push_back("SHADER_STAGE_GEOMETRY_BIT");
if (0x10 & value) strings.push_back("SHADER_STAGE_FRAGMENT_BIT");
if (0x20 & value) strings.push_back("SHADER_STAGE_COMPUTE_BIT");
if (0x0000001F & value) strings.push_back("SHADER_STAGE_ALL_GRAPHICS");
if (0x7FFFFFFF & value) strings.push_back("SHADER_STAGE_ALL");
if (0x100 & value) strings.push_back("SHADER_STAGE_RAYGEN_BIT_KHR");
if (0x200 & value) strings.push_back("SHADER_STAGE_ANY_HIT_BIT_KHR");
if (0x400 & value) strings.push_back("SHADER_STAGE_CLOSEST_HIT_BIT_KHR");
if (0x800 & value) strings.push_back("SHADER_STAGE_MISS_BIT_KHR");
if (0x1000 & value) strings.push_back("SHADER_STAGE_INTERSECTION_BIT_KHR");
if (0x2000 & value) strings.push_back("SHADER_STAGE_CALLABLE_BIT_KHR");
if (0x40 & value) strings.push_back("SHADER_STAGE_TASK_BIT_NV");
if (0x80 & value) strings.push_back("SHADER_STAGE_MESH_BIT_NV");
return strings;
}
void DumpVkShaderStageFlags(Printer &p, std::string name, VkShaderStageFlags value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkShaderStageFlagBitsGetStrings(static_cast<VkShaderStageFlagBits>(value));
if (static_cast<VkShaderStageFlagBits>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkShaderStageFlagBits(Printer &p, std::string name, VkShaderStageFlagBits value, int width = 0) {
auto strings = VkShaderStageFlagBitsGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkSubgroupFeatureFlagBitsGetStrings(VkSubgroupFeatureFlagBits value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("SUBGROUP_FEATURE_BASIC_BIT");
if (0x2 & value) strings.push_back("SUBGROUP_FEATURE_VOTE_BIT");
if (0x4 & value) strings.push_back("SUBGROUP_FEATURE_ARITHMETIC_BIT");
if (0x8 & value) strings.push_back("SUBGROUP_FEATURE_BALLOT_BIT");
if (0x10 & value) strings.push_back("SUBGROUP_FEATURE_SHUFFLE_BIT");
if (0x20 & value) strings.push_back("SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT");
if (0x40 & value) strings.push_back("SUBGROUP_FEATURE_CLUSTERED_BIT");
if (0x80 & value) strings.push_back("SUBGROUP_FEATURE_QUAD_BIT");
if (0x100 & value) strings.push_back("SUBGROUP_FEATURE_PARTITIONED_BIT_NV");
return strings;
}
void DumpVkSubgroupFeatureFlags(Printer &p, std::string name, VkSubgroupFeatureFlags value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkSubgroupFeatureFlagBitsGetStrings(static_cast<VkSubgroupFeatureFlagBits>(value));
if (static_cast<VkSubgroupFeatureFlagBits>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkSubgroupFeatureFlagBits(Printer &p, std::string name, VkSubgroupFeatureFlagBits value, int width = 0) {
auto strings = VkSubgroupFeatureFlagBitsGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkSurfaceCounterFlagBitsEXTGetStrings(VkSurfaceCounterFlagBitsEXT value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("SURFACE_COUNTER_VBLANK_EXT");
return strings;
}
void DumpVkSurfaceCounterFlagsEXT(Printer &p, std::string name, VkSurfaceCounterFlagsEXT value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(static_cast<VkSurfaceCounterFlagBitsEXT>(value));
if (static_cast<VkSurfaceCounterFlagBitsEXT>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkSurfaceCounterFlagBitsEXT(Printer &p, std::string name, VkSurfaceCounterFlagBitsEXT value, int width = 0) {
auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkSurfaceTransformFlagBitsKHRGetStrings(VkSurfaceTransformFlagBitsKHR value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("SURFACE_TRANSFORM_IDENTITY_BIT_KHR");
if (0x2 & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_90_BIT_KHR");
if (0x4 & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_180_BIT_KHR");
if (0x8 & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_270_BIT_KHR");
if (0x10 & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR");
if (0x20 & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR");
if (0x40 & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR");
if (0x80 & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR");
if (0x100 & value) strings.push_back("SURFACE_TRANSFORM_INHERIT_BIT_KHR");
return strings;
}
void DumpVkSurfaceTransformFlagsKHR(Printer &p, std::string name, VkSurfaceTransformFlagsKHR value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(static_cast<VkSurfaceTransformFlagBitsKHR>(value));
if (static_cast<VkSurfaceTransformFlagBitsKHR>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkSurfaceTransformFlagBitsKHR(Printer &p, std::string name, VkSurfaceTransformFlagBitsKHR value, int width = 0) {
auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
std::vector<const char *>VkToolPurposeFlagBitsEXTGetStrings(VkToolPurposeFlagBitsEXT value) {
std::vector<const char *> strings;
if (value == 0) strings.push_back("None");
if (0x1 & value) strings.push_back("TOOL_PURPOSE_VALIDATION_BIT_EXT");
if (0x2 & value) strings.push_back("TOOL_PURPOSE_PROFILING_BIT_EXT");
if (0x4 & value) strings.push_back("TOOL_PURPOSE_TRACING_BIT_EXT");
if (0x8 & value) strings.push_back("TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT");
if (0x10 & value) strings.push_back("TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT");
if (0x20 & value) strings.push_back("TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT");
if (0x40 & value) strings.push_back("TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT");
return strings;
}
void DumpVkToolPurposeFlagsEXT(Printer &p, std::string name, VkToolPurposeFlagsEXT value, int width = 0) {
if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
auto strings = VkToolPurposeFlagBitsEXTGetStrings(static_cast<VkToolPurposeFlagBitsEXT>(value));
if (static_cast<VkToolPurposeFlagBitsEXT>(value) == 0) {
ArrayWrapper arr(p, name, 0);
p.SetAsType().PrintString("None");
return;
}
ArrayWrapper arr(p, name, strings.size());
for(auto& str : strings){
p.SetAsType().PrintString(str);
}
}
void DumpVkToolPurposeFlagBitsEXT(Printer &p, std::string name, VkToolPurposeFlagBitsEXT value, int width = 0) {
auto strings = VkToolPurposeFlagBitsEXTGetStrings(value);
p.PrintKeyString(name, strings.at(0), width);
}
void DumpVkDrmFormatModifierPropertiesEXT(Printer &p, std::string name, VkDrmFormatModifierPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("drmFormatModifier", obj.drmFormatModifier, 27);
p.PrintKeyValue("drmFormatModifierPlaneCount", obj.drmFormatModifierPlaneCount, 27);
DumpVkFormatFeatureFlags(p, "drmFormatModifierTilingFeatures", obj.drmFormatModifierTilingFeatures, 27);
}
void DumpVkDrmFormatModifierPropertiesListEXT(Printer &p, std::string name, VkDrmFormatModifierPropertiesListEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("drmFormatModifierCount", obj.drmFormatModifierCount, 52);
ArrayWrapper arr(p,"pDrmFormatModifierProperties", obj.drmFormatModifierCount);
for (uint32_t i = 0; i < obj.drmFormatModifierCount; i++) {
if (obj.pDrmFormatModifierProperties != nullptr) {
p.SetElementIndex(i);
DumpVkDrmFormatModifierPropertiesEXT(p, "pDrmFormatModifierProperties", obj.pDrmFormatModifierProperties[i]);
}
}
}
void DumpVkExtent2D(Printer &p, std::string name, VkExtent2D &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("width", obj.width, 6);
p.PrintKeyValue("height", obj.height, 6);
}
void DumpVkExtent3D(Printer &p, std::string name, VkExtent3D &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("width", obj.width, 6);
p.PrintKeyValue("height", obj.height, 6);
p.PrintKeyValue("depth", obj.depth, 6);
}
void DumpVkLayerProperties(Printer &p, std::string name, VkLayerProperties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyString("layerName", obj.layerName, 21);
p.PrintKeyValue("specVersion", obj.specVersion, 21);
p.PrintKeyValue("implementationVersion", obj.implementationVersion, 21);
p.PrintKeyString("description", obj.description, 21);
}
void DumpVkPhysicalDevice16BitStorageFeatures(Printer &p, std::string name, VkPhysicalDevice16BitStorageFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess), 34);
p.PrintKeyBool("uniformAndStorageBuffer16BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer16BitAccess), 34);
p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16), 34);
p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16), 34);
}
void DumpVkPhysicalDevice8BitStorageFeatures(Printer &p, std::string name, VkPhysicalDevice8BitStorageFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess), 33);
p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess), 33);
p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8), 33);
}
void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceASTCDecodeFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("decodeModeSharedExponent", static_cast<bool>(obj.decodeModeSharedExponent), 24);
}
void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("advancedBlendCoherentOperations", static_cast<bool>(obj.advancedBlendCoherentOperations), 31);
}
void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("advancedBlendMaxColorAttachments", obj.advancedBlendMaxColorAttachments, 37);
p.PrintKeyBool("advancedBlendIndependentBlend", static_cast<bool>(obj.advancedBlendIndependentBlend), 37);
p.PrintKeyBool("advancedBlendNonPremultipliedSrcColor", static_cast<bool>(obj.advancedBlendNonPremultipliedSrcColor), 37);
p.PrintKeyBool("advancedBlendNonPremultipliedDstColor", static_cast<bool>(obj.advancedBlendNonPremultipliedDstColor), 37);
p.PrintKeyBool("advancedBlendCorrelatedOverlap", static_cast<bool>(obj.advancedBlendCorrelatedOverlap), 37);
p.PrintKeyBool("advancedBlendAllOperations", static_cast<bool>(obj.advancedBlendAllOperations), 37);
}
void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer &p, std::string name, VkPhysicalDeviceBufferDeviceAddressFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress), 32);
p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay), 32);
p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice), 32);
}
void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress), 32);
p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay), 32);
p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice), 32);
}
void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceConditionalRenderingFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("conditionalRendering", static_cast<bool>(obj.conditionalRendering), 29);
p.PrintKeyBool("inheritedConditionalRendering", static_cast<bool>(obj.inheritedConditionalRendering), 29);
}
void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceConservativeRasterizationPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("primitiveOverestimationSize", obj.primitiveOverestimationSize, 43);
p.PrintKeyValue("maxExtraPrimitiveOverestimationSize", obj.maxExtraPrimitiveOverestimationSize, 43);
p.PrintKeyValue("extraPrimitiveOverestimationSizeGranularity", obj.extraPrimitiveOverestimationSizeGranularity, 43);
p.PrintKeyBool("primitiveUnderestimation", static_cast<bool>(obj.primitiveUnderestimation), 43);
p.PrintKeyBool("conservativePointAndLineRasterization", static_cast<bool>(obj.conservativePointAndLineRasterization), 43);
p.PrintKeyBool("degenerateTrianglesRasterized", static_cast<bool>(obj.degenerateTrianglesRasterized), 43);
p.PrintKeyBool("degenerateLinesRasterized", static_cast<bool>(obj.degenerateLinesRasterized), 43);
p.PrintKeyBool("fullyCoveredFragmentShaderInputVariable", static_cast<bool>(obj.fullyCoveredFragmentShaderInputVariable), 43);
p.PrintKeyBool("conservativeRasterizationPostDepthCoverage", static_cast<bool>(obj.conservativeRasterizationPostDepthCoverage), 43);
}
void DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceCustomBorderColorFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("customBorderColors", static_cast<bool>(obj.customBorderColors), 30);
p.PrintKeyBool("customBorderColorWithoutFormat", static_cast<bool>(obj.customBorderColorWithoutFormat), 30);
}
void DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceCustomBorderColorPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxCustomBorderColorSamplers", obj.maxCustomBorderColorSamplers, 28);
}
void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceDepthClipEnableFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("depthClipEnable", static_cast<bool>(obj.depthClipEnable), 15);
}
void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer &p, std::string name, VkPhysicalDeviceDepthStencilResolveProperties &obj) {
ObjectWrapper object{p, name};
DumpVkResolveModeFlags(p, "supportedDepthResolveModes", obj.supportedDepthResolveModes, 22);
DumpVkResolveModeFlags(p, "supportedStencilResolveModes", obj.supportedStencilResolveModes, 22);
p.PrintKeyBool("independentResolveNone", static_cast<bool>(obj.independentResolveNone), 22);
p.PrintKeyBool("independentResolve", static_cast<bool>(obj.independentResolve), 22);
}
void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer &p, std::string name, VkPhysicalDeviceDescriptorIndexingFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing), 50);
p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing), 50);
p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing), 50);
p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing), 50);
p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending), 50);
p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound), 50);
p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount), 50);
p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray), 50);
}
void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer &p, std::string name, VkPhysicalDeviceDescriptorIndexingProperties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools, 52);
p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative), 52);
p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative), 52);
p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative), 52);
p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative), 52);
p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative), 52);
p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind), 52);
p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod), 52);
p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers, 52);
p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers, 52);
p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers, 52);
p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages, 52);
p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages, 52);
p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments", obj.maxPerStageDescriptorUpdateAfterBindInputAttachments, 52);
p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources, 52);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers, 52);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers, 52);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, 52);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers, 52);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, 52);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages, 52);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages, 52);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments, 52);
}
void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceDiscardRectanglePropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxDiscardRectangles", obj.maxDiscardRectangles, 20);
}
void DumpVkPhysicalDeviceDriverProperties(Printer &p, std::string name, VkPhysicalDeviceDriverProperties &obj) {
ObjectWrapper object{p, name};
DumpVkDriverId(p, "driverID", obj.driverID, 18);
p.PrintKeyString("driverName", obj.driverName, 18);
p.PrintKeyString("driverInfo", obj.driverInfo, 18);
DumpVkConformanceVersion(p, "conformanceVersion", obj.conformanceVersion, 18);
}
void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("extendedDynamicState", static_cast<bool>(obj.extendedDynamicState), 20);
}
void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceExternalMemoryHostPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("minImportedHostPointerAlignment", to_hex_str(p, obj.minImportedHostPointerAlignment), 31);
}
void DumpVkPhysicalDeviceFeatures(Printer &p, std::string name, VkPhysicalDeviceFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("robustBufferAccess", static_cast<bool>(obj.robustBufferAccess), 39);
p.PrintKeyBool("fullDrawIndexUint32", static_cast<bool>(obj.fullDrawIndexUint32), 39);
p.PrintKeyBool("imageCubeArray", static_cast<bool>(obj.imageCubeArray), 39);
p.PrintKeyBool("independentBlend", static_cast<bool>(obj.independentBlend), 39);
p.PrintKeyBool("geometryShader", static_cast<bool>(obj.geometryShader), 39);
p.PrintKeyBool("tessellationShader", static_cast<bool>(obj.tessellationShader), 39);
p.PrintKeyBool("sampleRateShading", static_cast<bool>(obj.sampleRateShading), 39);
p.PrintKeyBool("dualSrcBlend", static_cast<bool>(obj.dualSrcBlend), 39);
p.PrintKeyBool("logicOp", static_cast<bool>(obj.logicOp), 39);
p.PrintKeyBool("multiDrawIndirect", static_cast<bool>(obj.multiDrawIndirect), 39);
p.PrintKeyBool("drawIndirectFirstInstance", static_cast<bool>(obj.drawIndirectFirstInstance), 39);
p.PrintKeyBool("depthClamp", static_cast<bool>(obj.depthClamp), 39);
p.PrintKeyBool("depthBiasClamp", static_cast<bool>(obj.depthBiasClamp), 39);
p.PrintKeyBool("fillModeNonSolid", static_cast<bool>(obj.fillModeNonSolid), 39);
p.PrintKeyBool("depthBounds", static_cast<bool>(obj.depthBounds), 39);
p.PrintKeyBool("wideLines", static_cast<bool>(obj.wideLines), 39);
p.PrintKeyBool("largePoints", static_cast<bool>(obj.largePoints), 39);
p.PrintKeyBool("alphaToOne", static_cast<bool>(obj.alphaToOne), 39);
p.PrintKeyBool("multiViewport", static_cast<bool>(obj.multiViewport), 39);
p.PrintKeyBool("samplerAnisotropy", static_cast<bool>(obj.samplerAnisotropy), 39);
p.PrintKeyBool("textureCompressionETC2", static_cast<bool>(obj.textureCompressionETC2), 39);
p.PrintKeyBool("textureCompressionASTC_LDR", static_cast<bool>(obj.textureCompressionASTC_LDR), 39);
p.PrintKeyBool("textureCompressionBC", static_cast<bool>(obj.textureCompressionBC), 39);
p.PrintKeyBool("occlusionQueryPrecise", static_cast<bool>(obj.occlusionQueryPrecise), 39);
p.PrintKeyBool("pipelineStatisticsQuery", static_cast<bool>(obj.pipelineStatisticsQuery), 39);
p.PrintKeyBool("vertexPipelineStoresAndAtomics", static_cast<bool>(obj.vertexPipelineStoresAndAtomics), 39);
p.PrintKeyBool("fragmentStoresAndAtomics", static_cast<bool>(obj.fragmentStoresAndAtomics), 39);
p.PrintKeyBool("shaderTessellationAndGeometryPointSize", static_cast<bool>(obj.shaderTessellationAndGeometryPointSize), 39);
p.PrintKeyBool("shaderImageGatherExtended", static_cast<bool>(obj.shaderImageGatherExtended), 39);
p.PrintKeyBool("shaderStorageImageExtendedFormats", static_cast<bool>(obj.shaderStorageImageExtendedFormats), 39);
p.PrintKeyBool("shaderStorageImageMultisample", static_cast<bool>(obj.shaderStorageImageMultisample), 39);
p.PrintKeyBool("shaderStorageImageReadWithoutFormat", static_cast<bool>(obj.shaderStorageImageReadWithoutFormat), 39);
p.PrintKeyBool("shaderStorageImageWriteWithoutFormat", static_cast<bool>(obj.shaderStorageImageWriteWithoutFormat), 39);
p.PrintKeyBool("shaderUniformBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformBufferArrayDynamicIndexing), 39);
p.PrintKeyBool("shaderSampledImageArrayDynamicIndexing", static_cast<bool>(obj.shaderSampledImageArrayDynamicIndexing), 39);
p.PrintKeyBool("shaderStorageBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageBufferArrayDynamicIndexing), 39);
p.PrintKeyBool("shaderStorageImageArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageImageArrayDynamicIndexing), 39);
p.PrintKeyBool("shaderClipDistance", static_cast<bool>(obj.shaderClipDistance), 39);
p.PrintKeyBool("shaderCullDistance", static_cast<bool>(obj.shaderCullDistance), 39);
p.PrintKeyBool("shaderFloat64", static_cast<bool>(obj.shaderFloat64), 39);
p.PrintKeyBool("shaderInt64", static_cast<bool>(obj.shaderInt64), 39);
p.PrintKeyBool("shaderInt16", static_cast<bool>(obj.shaderInt16), 39);
p.PrintKeyBool("shaderResourceResidency", static_cast<bool>(obj.shaderResourceResidency), 39);
p.PrintKeyBool("shaderResourceMinLod", static_cast<bool>(obj.shaderResourceMinLod), 39);
p.PrintKeyBool("sparseBinding", static_cast<bool>(obj.sparseBinding), 39);
p.PrintKeyBool("sparseResidencyBuffer", static_cast<bool>(obj.sparseResidencyBuffer), 39);
p.PrintKeyBool("sparseResidencyImage2D", static_cast<bool>(obj.sparseResidencyImage2D), 39);
p.PrintKeyBool("sparseResidencyImage3D", static_cast<bool>(obj.sparseResidencyImage3D), 39);
p.PrintKeyBool("sparseResidency2Samples", static_cast<bool>(obj.sparseResidency2Samples), 39);
p.PrintKeyBool("sparseResidency4Samples", static_cast<bool>(obj.sparseResidency4Samples), 39);
p.PrintKeyBool("sparseResidency8Samples", static_cast<bool>(obj.sparseResidency8Samples), 39);
p.PrintKeyBool("sparseResidency16Samples", static_cast<bool>(obj.sparseResidency16Samples), 39);
p.PrintKeyBool("sparseResidencyAliased", static_cast<bool>(obj.sparseResidencyAliased), 39);
p.PrintKeyBool("variableMultisampleRate", static_cast<bool>(obj.variableMultisampleRate), 39);
p.PrintKeyBool("inheritedQueries", static_cast<bool>(obj.inheritedQueries), 39);
}
void DumpVkPhysicalDeviceFloatControlsProperties(Printer &p, std::string name, VkPhysicalDeviceFloatControlsProperties &obj) {
ObjectWrapper object{p, name};
DumpVkShaderFloatControlsIndependence(p, "denormBehaviorIndependence", obj.denormBehaviorIndependence, 37);
DumpVkShaderFloatControlsIndependence(p, "roundingModeIndependence", obj.roundingModeIndependence, 37);
p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat16", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat16), 37);
p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat32", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat32), 37);
p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat64", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat64), 37);
p.PrintKeyBool("shaderDenormPreserveFloat16", static_cast<bool>(obj.shaderDenormPreserveFloat16), 37);
p.PrintKeyBool("shaderDenormPreserveFloat32", static_cast<bool>(obj.shaderDenormPreserveFloat32), 37);
p.PrintKeyBool("shaderDenormPreserveFloat64", static_cast<bool>(obj.shaderDenormPreserveFloat64), 37);
p.PrintKeyBool("shaderDenormFlushToZeroFloat16", static_cast<bool>(obj.shaderDenormFlushToZeroFloat16), 37);
p.PrintKeyBool("shaderDenormFlushToZeroFloat32", static_cast<bool>(obj.shaderDenormFlushToZeroFloat32), 37);
p.PrintKeyBool("shaderDenormFlushToZeroFloat64", static_cast<bool>(obj.shaderDenormFlushToZeroFloat64), 37);
p.PrintKeyBool("shaderRoundingModeRTEFloat16", static_cast<bool>(obj.shaderRoundingModeRTEFloat16), 37);
p.PrintKeyBool("shaderRoundingModeRTEFloat32", static_cast<bool>(obj.shaderRoundingModeRTEFloat32), 37);
p.PrintKeyBool("shaderRoundingModeRTEFloat64", static_cast<bool>(obj.shaderRoundingModeRTEFloat64), 37);
p.PrintKeyBool("shaderRoundingModeRTZFloat16", static_cast<bool>(obj.shaderRoundingModeRTZFloat16), 37);
p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32), 37);
p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64), 37);
}
void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceFragmentDensityMapFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("fragmentDensityMap", static_cast<bool>(obj.fragmentDensityMap), 37);
p.PrintKeyBool("fragmentDensityMapDynamic", static_cast<bool>(obj.fragmentDensityMapDynamic), 37);
p.PrintKeyBool("fragmentDensityMapNonSubsampledImages", static_cast<bool>(obj.fragmentDensityMapNonSubsampledImages), 37);
}
void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceFragmentDensityMapPropertiesEXT &obj) {
ObjectWrapper object{p, name};
DumpVkExtent2D(p, "minFragmentDensityTexelSize", obj.minFragmentDensityTexelSize);
DumpVkExtent2D(p, "maxFragmentDensityTexelSize", obj.maxFragmentDensityTexelSize);
p.PrintKeyBool("fragmentDensityInvocations", static_cast<bool>(obj.fragmentDensityInvocations), 26);
}
void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("fragmentShaderSampleInterlock", static_cast<bool>(obj.fragmentShaderSampleInterlock), 34);
p.PrintKeyBool("fragmentShaderPixelInterlock", static_cast<bool>(obj.fragmentShaderPixelInterlock), 34);
p.PrintKeyBool("fragmentShaderShadingRateInterlock", static_cast<bool>(obj.fragmentShaderShadingRateInterlock), 34);
}
void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer &p, std::string name, VkPhysicalDeviceHostQueryResetFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset), 14);
}
void DumpVkPhysicalDeviceIDProperties(Printer &p, std::string name, VkPhysicalDeviceIDProperties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyString("deviceUUID", to_string_16(obj.deviceUUID), 15);
p.PrintKeyString("driverUUID", to_string_16(obj.driverUUID), 15);
if (obj.deviceLUIDValid) p.PrintKeyString("deviceLUID", to_string_8(obj.deviceLUID), 15);
p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask, 15);
p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid), 15);
}
void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer &p, std::string name, VkPhysicalDeviceImagelessFramebufferFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer), 20);
}
void DumpVkPhysicalDeviceIndexTypeUint8FeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceIndexTypeUint8FeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("indexTypeUint8", static_cast<bool>(obj.indexTypeUint8), 14);
}
void DumpVkPhysicalDeviceInlineUniformBlockFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceInlineUniformBlockFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("inlineUniformBlock", static_cast<bool>(obj.inlineUniformBlock), 50);
p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind", static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind), 50);
}
void DumpVkPhysicalDeviceInlineUniformBlockPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceInlineUniformBlockPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxInlineUniformBlockSize", obj.maxInlineUniformBlockSize, 55);
p.PrintKeyValue("maxPerStageDescriptorInlineUniformBlocks", obj.maxPerStageDescriptorInlineUniformBlocks, 55);
p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, 55);
p.PrintKeyValue("maxDescriptorSetInlineUniformBlocks", obj.maxDescriptorSetInlineUniformBlocks, 55);
p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInlineUniformBlocks", obj.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, 55);
}
void DumpVkPhysicalDeviceLimits(Printer &p, std::string name, VkPhysicalDeviceLimits &obj) {
if (p.Type() == OutputType::json)
p.ObjectStart("limits");
else
p.SetSubHeader().ObjectStart(name);
p.PrintKeyValue("maxImageDimension1D", obj.maxImageDimension1D, 47);
p.PrintKeyValue("maxImageDimension2D", obj.maxImageDimension2D, 47);
p.PrintKeyValue("maxImageDimension3D", obj.maxImageDimension3D, 47);
p.PrintKeyValue("maxImageDimensionCube", obj.maxImageDimensionCube, 47);
p.PrintKeyValue("maxImageArrayLayers", obj.maxImageArrayLayers, 47);
p.PrintKeyValue("maxTexelBufferElements", obj.maxTexelBufferElements, 47);
p.PrintKeyValue("maxUniformBufferRange", obj.maxUniformBufferRange, 47);
p.PrintKeyValue("maxStorageBufferRange", obj.maxStorageBufferRange, 47);
p.PrintKeyValue("maxPushConstantsSize", obj.maxPushConstantsSize, 47);
p.PrintKeyValue("maxMemoryAllocationCount", obj.maxMemoryAllocationCount, 47);
p.PrintKeyValue("maxSamplerAllocationCount", obj.maxSamplerAllocationCount, 47);
p.PrintKeyValue("bufferImageGranularity", to_hex_str(p, obj.bufferImageGranularity), 47);
p.PrintKeyValue("sparseAddressSpaceSize", to_hex_str(p, obj.sparseAddressSpaceSize), 47);
p.PrintKeyValue("maxBoundDescriptorSets", obj.maxBoundDescriptorSets, 47);
p.PrintKeyValue("maxPerStageDescriptorSamplers", obj.maxPerStageDescriptorSamplers, 47);
p.PrintKeyValue("maxPerStageDescriptorUniformBuffers", obj.maxPerStageDescriptorUniformBuffers, 47);
p.PrintKeyValue("maxPerStageDescriptorStorageBuffers", obj.maxPerStageDescriptorStorageBuffers, 47);
p.PrintKeyValue("maxPerStageDescriptorSampledImages", obj.maxPerStageDescriptorSampledImages, 47);
p.PrintKeyValue("maxPerStageDescriptorStorageImages", obj.maxPerStageDescriptorStorageImages, 47);
p.PrintKeyValue("maxPerStageDescriptorInputAttachments", obj.maxPerStageDescriptorInputAttachments, 47);
p.PrintKeyValue("maxPerStageResources", obj.maxPerStageResources, 47);
p.PrintKeyValue("maxDescriptorSetSamplers", obj.maxDescriptorSetSamplers, 47);
p.PrintKeyValue("maxDescriptorSetUniformBuffers", obj.maxDescriptorSetUniformBuffers, 47);
p.PrintKeyValue("maxDescriptorSetUniformBuffersDynamic", obj.maxDescriptorSetUniformBuffersDynamic, 47);
p.PrintKeyValue("maxDescriptorSetStorageBuffers", obj.maxDescriptorSetStorageBuffers, 47);
p.PrintKeyValue("maxDescriptorSetStorageBuffersDynamic", obj.maxDescriptorSetStorageBuffersDynamic, 47);
p.PrintKeyValue("maxDescriptorSetSampledImages", obj.maxDescriptorSetSampledImages, 47);
p.PrintKeyValue("maxDescriptorSetStorageImages", obj.maxDescriptorSetStorageImages, 47);
p.PrintKeyValue("maxDescriptorSetInputAttachments", obj.maxDescriptorSetInputAttachments, 47);
p.PrintKeyValue("maxVertexInputAttributes", obj.maxVertexInputAttributes, 47);
p.PrintKeyValue("maxVertexInputBindings", obj.maxVertexInputBindings, 47);
p.PrintKeyValue("maxVertexInputAttributeOffset", obj.maxVertexInputAttributeOffset, 47);
p.PrintKeyValue("maxVertexInputBindingStride", obj.maxVertexInputBindingStride, 47);
p.PrintKeyValue("maxVertexOutputComponents", obj.maxVertexOutputComponents, 47);
p.PrintKeyValue("maxTessellationGenerationLevel", obj.maxTessellationGenerationLevel, 47);
p.PrintKeyValue("maxTessellationPatchSize", obj.maxTessellationPatchSize, 47);
p.PrintKeyValue("maxTessellationControlPerVertexInputComponents", obj.maxTessellationControlPerVertexInputComponents, 47);
p.PrintKeyValue("maxTessellationControlPerVertexOutputComponents", obj.maxTessellationControlPerVertexOutputComponents, 47);
p.PrintKeyValue("maxTessellationControlPerPatchOutputComponents", obj.maxTessellationControlPerPatchOutputComponents, 47);
p.PrintKeyValue("maxTessellationControlTotalOutputComponents", obj.maxTessellationControlTotalOutputComponents, 47);
p.PrintKeyValue("maxTessellationEvaluationInputComponents", obj.maxTessellationEvaluationInputComponents, 47);
p.PrintKeyValue("maxTessellationEvaluationOutputComponents", obj.maxTessellationEvaluationOutputComponents, 47);
p.PrintKeyValue("maxGeometryShaderInvocations", obj.maxGeometryShaderInvocations, 47);
p.PrintKeyValue("maxGeometryInputComponents", obj.maxGeometryInputComponents, 47);
p.PrintKeyValue("maxGeometryOutputComponents", obj.maxGeometryOutputComponents, 47);
p.PrintKeyValue("maxGeometryOutputVertices", obj.maxGeometryOutputVertices, 47);
p.PrintKeyValue("maxGeometryTotalOutputComponents", obj.maxGeometryTotalOutputComponents, 47);
p.PrintKeyValue("maxFragmentInputComponents", obj.maxFragmentInputComponents, 47);
p.PrintKeyValue("maxFragmentOutputAttachments", obj.maxFragmentOutputAttachments, 47);
p.PrintKeyValue("maxFragmentDualSrcAttachments", obj.maxFragmentDualSrcAttachments, 47);
p.PrintKeyValue("maxFragmentCombinedOutputResources", obj.maxFragmentCombinedOutputResources, 47);
p.PrintKeyValue("maxComputeSharedMemorySize", obj.maxComputeSharedMemorySize, 47);
{ ArrayWrapper arr(p,"maxComputeWorkGroupCount", 3);
p.PrintElement(obj.maxComputeWorkGroupCount[0]);
p.PrintElement(obj.maxComputeWorkGroupCount[1]);
p.PrintElement(obj.maxComputeWorkGroupCount[2]);
}
p.PrintKeyValue("maxComputeWorkGroupInvocations", obj.maxComputeWorkGroupInvocations, 47);
{ ArrayWrapper arr(p,"maxComputeWorkGroupSize", 3);
p.PrintElement(obj.maxComputeWorkGroupSize[0]);
p.PrintElement(obj.maxComputeWorkGroupSize[1]);
p.PrintElement(obj.maxComputeWorkGroupSize[2]);
}
p.PrintKeyValue("subPixelPrecisionBits", obj.subPixelPrecisionBits, 47);
p.PrintKeyValue("subTexelPrecisionBits", obj.subTexelPrecisionBits, 47);
p.PrintKeyValue("mipmapPrecisionBits", obj.mipmapPrecisionBits, 47);
p.PrintKeyValue("maxDrawIndexedIndexValue", obj.maxDrawIndexedIndexValue, 47);
p.PrintKeyValue("maxDrawIndirectCount", obj.maxDrawIndirectCount, 47);
p.PrintKeyValue("maxSamplerLodBias", obj.maxSamplerLodBias, 47);
p.PrintKeyValue("maxSamplerAnisotropy", obj.maxSamplerAnisotropy, 47);
p.PrintKeyValue("maxViewports", obj.maxViewports, 47);
{ ArrayWrapper arr(p,"maxViewportDimensions", 2);
p.PrintElement(obj.maxViewportDimensions[0]);
p.PrintElement(obj.maxViewportDimensions[1]);
}
{ ArrayWrapper arr(p,"viewportBoundsRange", 2);
p.PrintElement(obj.viewportBoundsRange[0]);
p.PrintElement(obj.viewportBoundsRange[1]);
}
p.PrintKeyValue("viewportSubPixelBits", obj.viewportSubPixelBits, 47);
p.PrintKeyValue("minMemoryMapAlignment", obj.minMemoryMapAlignment, 47);
p.PrintKeyValue("minTexelBufferOffsetAlignment", to_hex_str(p, obj.minTexelBufferOffsetAlignment), 47);
p.PrintKeyValue("minUniformBufferOffsetAlignment", to_hex_str(p, obj.minUniformBufferOffsetAlignment), 47);
p.PrintKeyValue("minStorageBufferOffsetAlignment", to_hex_str(p, obj.minStorageBufferOffsetAlignment), 47);
p.PrintKeyValue("minTexelOffset", obj.minTexelOffset, 47);
p.PrintKeyValue("maxTexelOffset", obj.maxTexelOffset, 47);
p.PrintKeyValue("minTexelGatherOffset", obj.minTexelGatherOffset, 47);
p.PrintKeyValue("maxTexelGatherOffset", obj.maxTexelGatherOffset, 47);
p.PrintKeyValue("minInterpolationOffset", obj.minInterpolationOffset, 47);
p.PrintKeyValue("maxInterpolationOffset", obj.maxInterpolationOffset, 47);
p.PrintKeyValue("subPixelInterpolationOffsetBits", obj.subPixelInterpolationOffsetBits, 47);
p.PrintKeyValue("maxFramebufferWidth", obj.maxFramebufferWidth, 47);
p.PrintKeyValue("maxFramebufferHeight", obj.maxFramebufferHeight, 47);
p.PrintKeyValue("maxFramebufferLayers", obj.maxFramebufferLayers, 47);
DumpVkSampleCountFlags(p, "framebufferColorSampleCounts", obj.framebufferColorSampleCounts, 47);
DumpVkSampleCountFlags(p, "framebufferDepthSampleCounts", obj.framebufferDepthSampleCounts, 47);
DumpVkSampleCountFlags(p, "framebufferStencilSampleCounts", obj.framebufferStencilSampleCounts, 47);
DumpVkSampleCountFlags(p, "framebufferNoAttachmentsSampleCounts", obj.framebufferNoAttachmentsSampleCounts, 47);
p.PrintKeyValue("maxColorAttachments", obj.maxColorAttachments, 47);
DumpVkSampleCountFlags(p, "sampledImageColorSampleCounts", obj.sampledImageColorSampleCounts, 47);
DumpVkSampleCountFlags(p, "sampledImageIntegerSampleCounts", obj.sampledImageIntegerSampleCounts, 47);
DumpVkSampleCountFlags(p, "sampledImageDepthSampleCounts", obj.sampledImageDepthSampleCounts, 47);
DumpVkSampleCountFlags(p, "sampledImageStencilSampleCounts", obj.sampledImageStencilSampleCounts, 47);
DumpVkSampleCountFlags(p, "storageImageSampleCounts", obj.storageImageSampleCounts, 47);
p.PrintKeyValue("maxSampleMaskWords", obj.maxSampleMaskWords, 47);
p.PrintKeyBool("timestampComputeAndGraphics", static_cast<bool>(obj.timestampComputeAndGraphics), 47);
p.PrintKeyValue("timestampPeriod", obj.timestampPeriod, 47);
p.PrintKeyValue("maxClipDistances", obj.maxClipDistances, 47);
p.PrintKeyValue("maxCullDistances", obj.maxCullDistances, 47);
p.PrintKeyValue("maxCombinedClipAndCullDistances", obj.maxCombinedClipAndCullDistances, 47);
p.PrintKeyValue("discreteQueuePriorities", obj.discreteQueuePriorities, 47);
{ ArrayWrapper arr(p,"pointSizeRange", 2);
p.PrintElement(obj.pointSizeRange[0]);
p.PrintElement(obj.pointSizeRange[1]);
}
{ ArrayWrapper arr(p,"lineWidthRange", 2);
p.PrintElement(obj.lineWidthRange[0]);
p.PrintElement(obj.lineWidthRange[1]);
}
p.PrintKeyValue("pointSizeGranularity", obj.pointSizeGranularity, 47);
p.PrintKeyValue("lineWidthGranularity", obj.lineWidthGranularity, 47);
p.PrintKeyBool("strictLines", static_cast<bool>(obj.strictLines), 47);
p.PrintKeyBool("standardSampleLocations", static_cast<bool>(obj.standardSampleLocations), 47);
p.PrintKeyValue("optimalBufferCopyOffsetAlignment", to_hex_str(p, obj.optimalBufferCopyOffsetAlignment), 47);
p.PrintKeyValue("optimalBufferCopyRowPitchAlignment", to_hex_str(p, obj.optimalBufferCopyRowPitchAlignment), 47);
p.PrintKeyValue("nonCoherentAtomSize", to_hex_str(p, obj.nonCoherentAtomSize), 47);
p.ObjectEnd();
}
void DumpVkPhysicalDeviceLineRasterizationFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceLineRasterizationFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("rectangularLines", static_cast<bool>(obj.rectangularLines), 24);
p.PrintKeyBool("bresenhamLines", static_cast<bool>(obj.bresenhamLines), 24);
p.PrintKeyBool("smoothLines", static_cast<bool>(obj.smoothLines), 24);
p.PrintKeyBool("stippledRectangularLines", static_cast<bool>(obj.stippledRectangularLines), 24);
p.PrintKeyBool("stippledBresenhamLines", static_cast<bool>(obj.stippledBresenhamLines), 24);
p.PrintKeyBool("stippledSmoothLines", static_cast<bool>(obj.stippledSmoothLines), 24);
}
void DumpVkPhysicalDeviceLineRasterizationPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceLineRasterizationPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("lineSubPixelPrecisionBits", obj.lineSubPixelPrecisionBits, 25);
}
void DumpVkPhysicalDeviceMaintenance3Properties(Printer &p, std::string name, VkPhysicalDeviceMaintenance3Properties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors, 23);
p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize), 23);
}
void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceMemoryBudgetPropertiesEXT &obj) {
ObjectWrapper object{p, name};
{ ArrayWrapper arr(p,"heapBudget", 16);
p.PrintElement(obj.heapBudget[0]);
p.PrintElement(obj.heapBudget[1]);
p.PrintElement(obj.heapBudget[2]);
p.PrintElement(obj.heapBudget[3]);
p.PrintElement(obj.heapBudget[4]);
p.PrintElement(obj.heapBudget[5]);
p.PrintElement(obj.heapBudget[6]);
p.PrintElement(obj.heapBudget[7]);
p.PrintElement(obj.heapBudget[8]);
p.PrintElement(obj.heapBudget[9]);
p.PrintElement(obj.heapBudget[10]);
p.PrintElement(obj.heapBudget[11]);
p.PrintElement(obj.heapBudget[12]);
p.PrintElement(obj.heapBudget[13]);
p.PrintElement(obj.heapBudget[14]);
p.PrintElement(obj.heapBudget[15]);
}
{ ArrayWrapper arr(p,"heapUsage", 16);
p.PrintElement(obj.heapUsage[0]);
p.PrintElement(obj.heapUsage[1]);
p.PrintElement(obj.heapUsage[2]);
p.PrintElement(obj.heapUsage[3]);
p.PrintElement(obj.heapUsage[4]);
p.PrintElement(obj.heapUsage[5]);
p.PrintElement(obj.heapUsage[6]);
p.PrintElement(obj.heapUsage[7]);
p.PrintElement(obj.heapUsage[8]);
p.PrintElement(obj.heapUsage[9]);
p.PrintElement(obj.heapUsage[10]);
p.PrintElement(obj.heapUsage[11]);
p.PrintElement(obj.heapUsage[12]);
p.PrintElement(obj.heapUsage[13]);
p.PrintElement(obj.heapUsage[14]);
p.PrintElement(obj.heapUsage[15]);
}
}
void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceMemoryPriorityFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("memoryPriority", static_cast<bool>(obj.memoryPriority), 14);
}
void DumpVkPhysicalDeviceMultiviewFeatures(Printer &p, std::string name, VkPhysicalDeviceMultiviewFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview), 27);
p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader), 27);
p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader), 27);
}
void DumpVkPhysicalDeviceMultiviewProperties(Printer &p, std::string name, VkPhysicalDeviceMultiviewProperties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount, 25);
p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex, 25);
}
void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer &p, std::string name, VkPhysicalDevicePCIBusInfoPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("pciDomain", obj.pciDomain, 11);
p.PrintKeyValue("pciBus", obj.pciBus, 11);
p.PrintKeyValue("pciDevice", obj.pciDevice, 11);
p.PrintKeyValue("pciFunction", obj.pciFunction, 11);
}
void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer &p, std::string name, VkPhysicalDevicePerformanceQueryFeaturesKHR &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("performanceCounterQueryPools", static_cast<bool>(obj.performanceCounterQueryPools), 36);
p.PrintKeyBool("performanceCounterMultipleQueryPools", static_cast<bool>(obj.performanceCounterMultipleQueryPools), 36);
}
void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer &p, std::string name, VkPhysicalDevicePerformanceQueryPropertiesKHR &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("allowCommandBufferQueryCopies", static_cast<bool>(obj.allowCommandBufferQueryCopies), 29);
}
void DumpVkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(Printer &p, std::string name, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("pipelineCreationCacheControl", static_cast<bool>(obj.pipelineCreationCacheControl), 28);
}
void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(Printer &p, std::string name, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("pipelineExecutableInfo", static_cast<bool>(obj.pipelineExecutableInfo), 22);
}
void DumpVkPhysicalDevicePointClippingProperties(Printer &p, std::string name, VkPhysicalDevicePointClippingProperties &obj) {
ObjectWrapper object{p, name};
DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior, 0);
}
void DumpVkPhysicalDevicePrivateDataFeaturesEXT(Printer &p, std::string name, VkPhysicalDevicePrivateDataFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("privateData", static_cast<bool>(obj.privateData), 11);
}
void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer &p, std::string name, VkPhysicalDeviceProtectedMemoryFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory), 15);
}
void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer &p, std::string name, VkPhysicalDeviceProtectedMemoryProperties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault), 16);
}
void DumpVkPhysicalDevicePushDescriptorPropertiesKHR(Printer &p, std::string name, VkPhysicalDevicePushDescriptorPropertiesKHR &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxPushDescriptors", obj.maxPushDescriptors, 18);
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
void DumpVkPhysicalDeviceRayTracingFeaturesKHR(Printer &p, std::string name, VkPhysicalDeviceRayTracingFeaturesKHR &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("rayTracing", static_cast<bool>(obj.rayTracing), 45);
p.PrintKeyBool("rayTracingShaderGroupHandleCaptureReplay", static_cast<bool>(obj.rayTracingShaderGroupHandleCaptureReplay), 45);
p.PrintKeyBool("rayTracingShaderGroupHandleCaptureReplayMixed", static_cast<bool>(obj.rayTracingShaderGroupHandleCaptureReplayMixed), 45);
p.PrintKeyBool("rayTracingAccelerationStructureCaptureReplay", static_cast<bool>(obj.rayTracingAccelerationStructureCaptureReplay), 45);
p.PrintKeyBool("rayTracingIndirectTraceRays", static_cast<bool>(obj.rayTracingIndirectTraceRays), 45);
p.PrintKeyBool("rayTracingIndirectAccelerationStructureBuild", static_cast<bool>(obj.rayTracingIndirectAccelerationStructureBuild), 45);
p.PrintKeyBool("rayTracingHostAccelerationStructureCommands", static_cast<bool>(obj.rayTracingHostAccelerationStructureCommands), 45);
p.PrintKeyBool("rayQuery", static_cast<bool>(obj.rayQuery), 45);
p.PrintKeyBool("rayTracingPrimitiveCulling", static_cast<bool>(obj.rayTracingPrimitiveCulling), 45);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
void DumpVkPhysicalDeviceRayTracingPropertiesKHR(Printer &p, std::string name, VkPhysicalDeviceRayTracingPropertiesKHR &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("shaderGroupHandleSize", obj.shaderGroupHandleSize, 38);
p.PrintKeyValue("maxRecursionDepth", obj.maxRecursionDepth, 38);
p.PrintKeyValue("maxShaderGroupStride", obj.maxShaderGroupStride, 38);
p.PrintKeyValue("shaderGroupBaseAlignment", obj.shaderGroupBaseAlignment, 38);
p.PrintKeyValue("maxGeometryCount", obj.maxGeometryCount, 38);
p.PrintKeyValue("maxInstanceCount", obj.maxInstanceCount, 38);
p.PrintKeyValue("maxPrimitiveCount", obj.maxPrimitiveCount, 38);
p.PrintKeyValue("maxDescriptorSetAccelerationStructures", obj.maxDescriptorSetAccelerationStructures, 38);
p.PrintKeyValue("shaderGroupHandleCaptureReplaySize", obj.shaderGroupHandleCaptureReplaySize, 38);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void DumpVkPhysicalDeviceRobustness2FeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceRobustness2FeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("robustBufferAccess2", static_cast<bool>(obj.robustBufferAccess2), 19);
p.PrintKeyBool("robustImageAccess2", static_cast<bool>(obj.robustImageAccess2), 19);
p.PrintKeyBool("nullDescriptor", static_cast<bool>(obj.nullDescriptor), 19);
}
void DumpVkPhysicalDeviceRobustness2PropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceRobustness2PropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("robustStorageBufferAccessSizeAlignment", to_hex_str(p, obj.robustStorageBufferAccessSizeAlignment), 38);
p.PrintKeyValue("robustUniformBufferAccessSizeAlignment", to_hex_str(p, obj.robustUniformBufferAccessSizeAlignment), 38);
}
void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceSampleLocationsPropertiesEXT &obj) {
ObjectWrapper object{p, name};
DumpVkSampleCountFlags(p, "sampleLocationSampleCounts", obj.sampleLocationSampleCounts, 32);
DumpVkExtent2D(p, "maxSampleLocationGridSize", obj.maxSampleLocationGridSize);
{ ArrayWrapper arr(p,"sampleLocationCoordinateRange", 2);
p.PrintElement(obj.sampleLocationCoordinateRange[0]);
p.PrintElement(obj.sampleLocationCoordinateRange[1]);
}
p.PrintKeyValue("sampleLocationSubPixelBits", obj.sampleLocationSubPixelBits, 32);
p.PrintKeyBool("variableSampleLocations", static_cast<bool>(obj.variableSampleLocations), 32);
}
void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer &p, std::string name, VkPhysicalDeviceSamplerFilterMinmaxProperties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("filterMinmaxSingleComponentFormats", static_cast<bool>(obj.filterMinmaxSingleComponentFormats), 34);
p.PrintKeyBool("filterMinmaxImageComponentMapping", static_cast<bool>(obj.filterMinmaxImageComponentMapping), 34);
}
void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer &p, std::string name, VkPhysicalDeviceSamplerYcbcrConversionFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion), 22);
}
void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer &p, std::string name, VkPhysicalDeviceScalarBlockLayoutFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout), 17);
}
void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer &p, std::string name, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts), 27);
}
void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer &p, std::string name, VkPhysicalDeviceShaderAtomicInt64Features &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics), 24);
p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics), 24);
}
void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer &p, std::string name, VkPhysicalDeviceShaderClockFeaturesKHR &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("shaderSubgroupClock", static_cast<bool>(obj.shaderSubgroupClock), 19);
p.PrintKeyBool("shaderDeviceClock", static_cast<bool>(obj.shaderDeviceClock), 19);
}
void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("shaderDemoteToHelperInvocation", static_cast<bool>(obj.shaderDemoteToHelperInvocation), 30);
}
void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer &p, std::string name, VkPhysicalDeviceShaderDrawParametersFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters), 20);
}
void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer &p, std::string name, VkPhysicalDeviceShaderFloat16Int8Features &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16), 13);
p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8), 13);
}
void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer &p, std::string name, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes), 27);
}
void DumpVkPhysicalDeviceSparseProperties(Printer &p, std::string name, VkPhysicalDeviceSparseProperties &obj) {
if (p.Type() == OutputType::json)
p.ObjectStart("sparseProperties");
else
p.SetSubHeader().ObjectStart(name);
p.PrintKeyBool("residencyStandard2DBlockShape", static_cast<bool>(obj.residencyStandard2DBlockShape), 40);
p.PrintKeyBool("residencyStandard2DMultisampleBlockShape", static_cast<bool>(obj.residencyStandard2DMultisampleBlockShape), 40);
p.PrintKeyBool("residencyStandard3DBlockShape", static_cast<bool>(obj.residencyStandard3DBlockShape), 40);
p.PrintKeyBool("residencyAlignedMipSize", static_cast<bool>(obj.residencyAlignedMipSize), 40);
p.PrintKeyBool("residencyNonResidentStrict", static_cast<bool>(obj.residencyNonResidentStrict), 40);
p.ObjectEnd();
}
void DumpVkPhysicalDeviceSubgroupProperties(Printer &p, std::string name, VkPhysicalDeviceSubgroupProperties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("subgroupSize", obj.subgroupSize, 25);
DumpVkShaderStageFlags(p, "supportedStages", obj.supportedStages, 25);
DumpVkSubgroupFeatureFlags(p, "supportedOperations", obj.supportedOperations, 25);
p.PrintKeyBool("quadOperationsInAllStages", static_cast<bool>(obj.quadOperationsInAllStages), 25);
}
void DumpVkPhysicalDeviceSubgroupSizeControlFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("subgroupSizeControl", static_cast<bool>(obj.subgroupSizeControl), 20);
p.PrintKeyBool("computeFullSubgroups", static_cast<bool>(obj.computeFullSubgroups), 20);
}
void DumpVkPhysicalDeviceSubgroupSizeControlPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("minSubgroupSize", obj.minSubgroupSize, 28);
p.PrintKeyValue("maxSubgroupSize", obj.maxSubgroupSize, 28);
p.PrintKeyValue("maxComputeWorkgroupSubgroups", obj.maxComputeWorkgroupSubgroups, 28);
DumpVkShaderStageFlags(p, "requiredSubgroupSizeStages", obj.requiredSubgroupSizeStages, 28);
}
void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("texelBufferAlignment", static_cast<bool>(obj.texelBufferAlignment), 20);
}
void DumpVkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("storageTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.storageTexelBufferOffsetAlignmentBytes), 44);
p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment", static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment), 44);
p.PrintKeyValue("uniformTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.uniformTexelBufferOffsetAlignmentBytes), 44);
p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment", static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment), 44);
}
void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("textureCompressionASTC_HDR", static_cast<bool>(obj.textureCompressionASTC_HDR), 26);
}
void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer &p, std::string name, VkPhysicalDeviceTimelineSemaphoreFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore), 17);
}
void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer &p, std::string name, VkPhysicalDeviceTimelineSemaphoreProperties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference, 35);
}
void DumpVkPhysicalDeviceToolPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceToolPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyString("name", obj.name, 16);
p.PrintKeyString("version", obj.version, 16);
DumpVkToolPurposeFlagsEXT(p, "purposes", obj.purposes, 16);
p.PrintKeyString("description", obj.description, 16);
p.PrintKeyString("layer", obj.layer, 16);
}
void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceTransformFeedbackFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("transformFeedback", static_cast<bool>(obj.transformFeedback), 17);
p.PrintKeyBool("geometryStreams", static_cast<bool>(obj.geometryStreams), 17);
}
void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceTransformFeedbackPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxTransformFeedbackStreams", obj.maxTransformFeedbackStreams, 42);
p.PrintKeyValue("maxTransformFeedbackBuffers", obj.maxTransformFeedbackBuffers, 42);
p.PrintKeyValue("maxTransformFeedbackBufferSize", to_hex_str(p, obj.maxTransformFeedbackBufferSize), 42);
p.PrintKeyValue("maxTransformFeedbackStreamDataSize", obj.maxTransformFeedbackStreamDataSize, 42);
p.PrintKeyValue("maxTransformFeedbackBufferDataSize", obj.maxTransformFeedbackBufferDataSize, 42);
p.PrintKeyValue("maxTransformFeedbackBufferDataStride", obj.maxTransformFeedbackBufferDataStride, 42);
p.PrintKeyBool("transformFeedbackQueries", static_cast<bool>(obj.transformFeedbackQueries), 42);
p.PrintKeyBool("transformFeedbackStreamsLinesTriangles", static_cast<bool>(obj.transformFeedbackStreamsLinesTriangles), 42);
p.PrintKeyBool("transformFeedbackRasterizationStreamSelect", static_cast<bool>(obj.transformFeedbackRasterizationStreamSelect), 42);
p.PrintKeyBool("transformFeedbackDraw", static_cast<bool>(obj.transformFeedbackDraw), 42);
}
void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer &p, std::string name, VkPhysicalDeviceUniformBufferStandardLayoutFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout), 27);
}
void DumpVkPhysicalDeviceVariablePointersFeatures(Printer &p, std::string name, VkPhysicalDeviceVariablePointersFeatures &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer), 29);
p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers), 29);
}
void DumpVkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("vertexAttributeInstanceRateDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateDivisor), 38);
p.PrintKeyBool("vertexAttributeInstanceRateZeroDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateZeroDivisor), 38);
}
void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &obj) {
ObjectWrapper object{p, name};
p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor, 22);
}
void DumpVkPhysicalDeviceVulkan11Features(Printer &p, std::string name, VkPhysicalDeviceVulkan11Features &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess), 34);
p.PrintKeyBool("uniformAndStorageBuffer16BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer16BitAccess), 34);
p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16), 34);
p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16), 34);
p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview), 34);
p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader), 34);
p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader), 34);
p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer), 34);
p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers), 34);
p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory), 34);
p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion), 34);
p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters), 34);
}
void DumpVkPhysicalDeviceVulkan11Properties(Printer &p, std::string name, VkPhysicalDeviceVulkan11Properties &obj) {
ObjectWrapper object{p, name};
p.PrintKeyString("deviceUUID", to_string_16(obj.deviceUUID), 33);
p.PrintKeyString("driverUUID", to_string_16(obj.driverUUID), 33);
if (obj.deviceLUIDValid) p.PrintKeyString("deviceLUID", to_string_8(obj.deviceLUID), 33);
p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask, 33);
p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid), 33);
p.PrintKeyValue("subgroupSize", obj.subgroupSize, 33);
DumpVkShaderStageFlags(p, "subgroupSupportedStages", obj.subgroupSupportedStages, 33);
DumpVkSubgroupFeatureFlags(p, "subgroupSupportedOperations", obj.subgroupSupportedOperations, 33);
p.PrintKeyBool("subgroupQuadOperationsInAllStages", static_cast<bool>(obj.subgroupQuadOperationsInAllStages), 33);
DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior, 33);
p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount, 33);
p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex, 33);
p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault), 33);
p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors, 33);
p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize), 33);
}
void DumpVkPhysicalDeviceVulkan12Features(Printer &p, std::string name, VkPhysicalDeviceVulkan12Features &obj) {
ObjectWrapper object{p, name};
p.PrintKeyBool("samplerMirrorClampToEdge", static_cast<bool>(obj.samplerMirrorClampToEdge), 50);
p.PrintKeyBool("drawIndirectCount", static_cast<bool>(obj.drawIndirectCount), 50);
p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess), 50);
p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess), 50);
p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8), 50);
p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics), 50);
p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics), 50);
p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16), 50);
p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8), 50);
p.PrintKeyBool("descriptorIndexing", static_cast<bool>(obj.descriptorIndexing), 50);
p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing), 50);
p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing), 50);
p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing), 50);
p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing), 50);
p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing), 50);
p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind), 50);
p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending), 50);
p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound), 50);
p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount), 50);
p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray), 50);
p.PrintKeyBool("samplerFilterMinmax", static_cast<bool>(obj.samplerFilterMinmax), 50);
p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout), 50);
p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer), 50);
p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout), 50);
p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes), 50);
p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts), 50);
p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset), 50);
p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore), 50);
p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress), 50);
p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay), 50);
p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice), 50);
p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel), 50);
p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope), 50);
p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains", static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains), 50);
p.PrintKeyBool("shaderOutputViewportIndex", static_cast<bool>(obj.shaderOutputViewportIndex), 50