| #ifndef _VULKAN_JSON_DATA_HPP |
| #define _VULKAN_JSON_DATA_HPP |
| |
| /* |
| * Copyright (c) 2021 The Khronos Group 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. |
| * |
| *//*! |
| * \file |
| * \brief Defines JSON generators for Vulkan structures |
| */ |
| |
| |
| /********************************************************************************************/ |
| /** This code is generated. To make changes, please modify the scripts or the relevant xml **/ |
| /********************************************************************************************/ |
| |
| #include <iostream> |
| #include <map> |
| #include <bitset> |
| #include <functional> |
| #include <sstream> |
| #include <cassert> |
| #include <cmath> |
| #ifndef VULKAN_JSON_CTS |
| #include <vulkan/vulkan.h> |
| #endif |
| |
| #ifdef _WIN32 |
| #ifndef WIN32_LEAN_AND_MEAN |
| #define WIN32_LEAN_AND_MEAN |
| #endif |
| #define VC_EXTRALEAN |
| #define NOMINMAX |
| #include <windows.h> |
| #endif |
| |
| namespace vk_json { |
| |
| static thread_local int s_num_spaces = 0; |
| static thread_local std::stringstream _string_stream; |
| |
| static void dumpPNextChain(const void* pNext); |
| |
| // By default, redirect to std::cout. Can stream it to a stringstream if needed. |
| //#define _OUT std::cout |
| #define _OUT _string_stream |
| |
| // Helper utility to do indentation in the generated json file. |
| #define PRINT_SPACE for (int k = 0; k < s_num_spaces; k++) _OUT << " "; |
| |
| #define INDENT(sz) s_num_spaces += (sz); |
| |
| #define PRINT_VAL(c) PRINT_SPACE \ |
| if (s != "") {\ |
| _OUT << "\"" << s << "\"" << " : " << o << (c ? "," : "") << std::endl; \ |
| } else {\ |
| _OUT << o << (c ? "," : "") << std::endl; \ |
| } |
| |
| #define PRINT_STR(c) PRINT_SPACE \ |
| if (s != "") {\ |
| _OUT << "\"" << s << "\"" << " : " << "\"" << o << "\"" << (c ? "," : "") << std::endl; \ |
| } else {\ |
| _OUT << "\"" << o << "\"" << (c ? "," : "") << std::endl; \ |
| } |
| |
| // To make sure the generated data is consistent across platforms, |
| // we typecast to 32-bit and dump the data. |
| // The value is not expected to exceed the range. |
| static void print_size_t(const size_t* o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_SPACE |
| _OUT << "\"" << s << "\"" << " : " << static_cast<deUint32>(*o) << (commaNeeded ? "," : "") << std::endl;\ |
| } |
| static void print_size_t(size_t o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_SPACE |
| _OUT << "\"" << s << "\"" << " : " << static_cast<deUint32>(o) << (commaNeeded ? "," : "") << std::endl;\ |
| } |
| |
| static void print_int32_t(deInt32 o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_int32_t(const deInt32 * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_uint32_t(deUint32 o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_uint32_t(const deUint32 * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_uint8_t(deUint8 o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_uint8_t(const deUint8 * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_uint64_t(deUint64 o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_uint64_t(const deUint64 * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_float(float o, const std::string& s, bool commaNeeded=true) |
| { |
| if (std::isnan(o)) |
| { |
| PRINT_SPACE |
| if (s != "") |
| _OUT << "\"" << s << "\"" << " : \"NaN\"" << (commaNeeded ? "," : "") << std::endl; |
| else |
| _OUT << "\"NaN\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| else |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| } |
| |
| static void print_float(const float * o, const std::string& s, bool commaNeeded=true) |
| { |
| if (std::isnan(*o)) |
| { |
| PRINT_SPACE |
| if (s != "") |
| _OUT << "\"" << s << "\"" << " : \"NaN\"" << (commaNeeded ? "," : "") << std::endl; |
| else |
| _OUT << "\"NaN\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| else |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| } |
| |
| static void print_int(int o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_int(const int * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_double(double o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_double(const double * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_int64_t(deInt64 o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_int64_t(const deInt64 * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_uint16_t(deUint16 o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_uint16_t(const deUint16 * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_char(const char * const* o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_STR(commaNeeded) |
| } |
| |
| static void print_char(char o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_VAL(commaNeeded) |
| } |
| |
| static void print_char(const char * o, const std::string& s, bool commaNeeded=true) |
| { |
| PRINT_STR(commaNeeded) |
| } |
| |
| |
| // Base 64 formater class from executor/xeTestLogWriter.cpp |
| |
| class Base64Formatter |
| { |
| public: |
| const deUint8* data; |
| int numBytes; |
| |
| Base64Formatter(const deUint8* data_, int numBytes_) : data(data_), numBytes(numBytes_) {} |
| }; |
| |
| std::ostream& operator<< (std::ostream& str, const Base64Formatter& fmt) |
| { |
| static const char s_base64Table[64] = |
| { |
| 'A','B','C','D','E','F','G','H','I','J','K','L','M', |
| 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z', |
| 'a','b','c','d','e','f','g','h','i','j','k','l','m', |
| 'n','o','p','q','r','s','t','u','v','w','x','y','z', |
| '0','1','2','3','4','5','6','7','8','9','+','/' |
| }; |
| |
| const deUint8* data = fmt.data; |
| int numBytes = fmt.numBytes; |
| int srcNdx = 0; |
| |
| DE_ASSERT(data && (numBytes > 0)); |
| |
| /* Loop all input chars. */ |
| while (srcNdx < numBytes) |
| { |
| int numRead = de::min(3, numBytes - srcNdx); |
| deUint8 s0 = data[srcNdx]; |
| deUint8 s1 = (numRead >= 2) ? data[srcNdx + 1] : 0; |
| deUint8 s2 = (numRead >= 3) ? data[srcNdx + 2] : 0; |
| char d[4]; |
| |
| srcNdx += numRead; |
| |
| d[0] = s_base64Table[s0 >> 2]; |
| d[1] = s_base64Table[((s0 & 0x3) << 4) | (s1 >> 4)]; |
| d[2] = s_base64Table[((s1 & 0xF) << 2) | (s2 >> 6)]; |
| d[3] = s_base64Table[s2 & 0x3F]; |
| |
| if (numRead < 3) d[3] = '='; |
| if (numRead < 2) d[2] = '='; |
| |
| /* Write data. */ |
| str.write(&d[0], sizeof(d)); |
| } |
| |
| return str; |
| } |
| |
| inline Base64Formatter toBase64(const deUint8* bytes, int numBytes) {return Base64Formatter(bytes, numBytes); } |
| |
| static void print_void_data(const void * o, int oSize, const std::string& s, bool commaNeeded=true) |
| { |
| if (o != NULL && oSize != 0) |
| { |
| PRINT_SPACE _OUT << "\"" << s << "\"" << " : " << "\"" << toBase64((deUint8*)o, oSize) << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| else |
| { |
| PRINT_SPACE _OUT << "\"" << s << "\"" << " : " << "\"NULL\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| } |
| |
| static void print_VkBool32(VkBool32 obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << ((obj == 0) ? ("VK_FALSE") : ("VK_TRUE")) << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| static void print_VkBool32(const VkBool32 * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << ((obj == 0) ? ("VK_FALSE") : ("VK_TRUE")) << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| |
| static void print_VkDeviceAddress(VkDeviceAddress obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| static void print_VkDeviceAddress(const VkDeviceAddress * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| |
| static void print_VkDeviceSize(VkDeviceSize obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| static void print_VkDeviceSize(const VkDeviceSize * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| |
| static void print_VkFlags(VkFlags obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| static void print_VkFlags(const VkFlags * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| |
| static void print_VkSampleMask(VkSampleMask obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| static void print_VkSampleMask(const VkSampleMask * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; |
| } |
| |
| static void print_VkBuffer(VkBuffer obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkBuffer(const VkBuffer * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkImage(VkImage obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkImage(const VkImage * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkInstance(VkInstance obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkInstance(const VkInstance * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkPhysicalDevice(VkPhysicalDevice obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkPhysicalDevice(const VkPhysicalDevice * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkDevice(VkDevice obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkDevice(const VkDevice * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkQueue(VkQueue obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkQueue(const VkQueue * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkSemaphore(VkSemaphore obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkSemaphore(const VkSemaphore * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkCommandBuffer(VkCommandBuffer obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkCommandBuffer(const VkCommandBuffer * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkFence(VkFence obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkFence(const VkFence * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkDeviceMemory(VkDeviceMemory obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkDeviceMemory(const VkDeviceMemory * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkEvent(VkEvent obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkEvent(const VkEvent * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkQueryPool(VkQueryPool obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkQueryPool(const VkQueryPool * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkBufferView(VkBufferView obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkBufferView(const VkBufferView * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkImageView(VkImageView obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkImageView(const VkImageView * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkShaderModule(VkShaderModule obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkShaderModule(const VkShaderModule * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkPipelineCache(VkPipelineCache obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkPipelineCache(const VkPipelineCache * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkPipelineLayout(VkPipelineLayout obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkPipelineLayout(const VkPipelineLayout * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkPipeline(VkPipeline obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkPipeline(const VkPipeline * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkRenderPass(VkRenderPass obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkRenderPass(const VkRenderPass * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkDescriptorSetLayout(VkDescriptorSetLayout obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkDescriptorSetLayout(const VkDescriptorSetLayout * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkSampler(VkSampler obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkSampler(const VkSampler * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkDescriptorSet(VkDescriptorSet obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkDescriptorSet(const VkDescriptorSet * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkDescriptorPool(VkDescriptorPool obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkDescriptorPool(const VkDescriptorPool * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkFramebuffer(VkFramebuffer obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkFramebuffer(const VkFramebuffer * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static void print_VkCommandPool(VkCommandPool obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| static void print_VkCommandPool(const VkCommandPool * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (commaNeeded) |
| _OUT << "\"" << str << "\"" << "," << std::endl; |
| else |
| _OUT << "\"" << str << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkResult_map = { |
| std::make_pair(0, "VK_SUCCESS"), |
| std::make_pair(1, "VK_NOT_READY"), |
| std::make_pair(2, "VK_TIMEOUT"), |
| std::make_pair(3, "VK_EVENT_SET"), |
| std::make_pair(4, "VK_EVENT_RESET"), |
| std::make_pair(5, "VK_INCOMPLETE"), |
| std::make_pair(-1, "VK_ERROR_OUT_OF_HOST_MEMORY"), |
| std::make_pair(-2, "VK_ERROR_OUT_OF_DEVICE_MEMORY"), |
| std::make_pair(-3, "VK_ERROR_INITIALIZATION_FAILED"), |
| std::make_pair(-4, "VK_ERROR_DEVICE_LOST"), |
| std::make_pair(-5, "VK_ERROR_MEMORY_MAP_FAILED"), |
| std::make_pair(-6, "VK_ERROR_LAYER_NOT_PRESENT"), |
| std::make_pair(-7, "VK_ERROR_EXTENSION_NOT_PRESENT"), |
| std::make_pair(-8, "VK_ERROR_FEATURE_NOT_PRESENT"), |
| std::make_pair(-9, "VK_ERROR_INCOMPATIBLE_DRIVER"), |
| std::make_pair(-10, "VK_ERROR_TOO_MANY_OBJECTS"), |
| std::make_pair(-11, "VK_ERROR_FORMAT_NOT_SUPPORTED"), |
| std::make_pair(-12, "VK_ERROR_FRAGMENTED_POOL"), |
| std::make_pair(-13, "VK_ERROR_UNKNOWN"), |
| std::make_pair(1000069000, "VK_ERROR_OUT_OF_POOL_MEMORY"), |
| std::make_pair(1000072003, "VK_ERROR_INVALID_EXTERNAL_HANDLE"), |
| std::make_pair(1000161000, "VK_ERROR_FRAGMENTATION"), |
| std::make_pair(1000257000, "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"), |
| std::make_pair(1000011001, "VK_ERROR_VALIDATION_FAILED"), |
| std::make_pair(1000298000, "VK_ERROR_INVALID_PIPELINE_CACHE_DATA"), |
| std::make_pair(1000298001, "VK_ERROR_NO_PIPELINE_MATCH"), |
| std::make_pair(1000000000, "VK_ERROR_SURFACE_LOST_KHR"), |
| std::make_pair(1000000001, "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"), |
| std::make_pair(1000001003, "VK_SUBOPTIMAL_KHR"), |
| std::make_pair(1000001004, "VK_ERROR_OUT_OF_DATE_KHR"), |
| std::make_pair(1000003001, "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"), |
| std::make_pair(1000012000, "VK_ERROR_INVALID_SHADER_NV"), |
| std::make_pair(1000158000, "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"), |
| std::make_pair(1000174001, "VK_ERROR_NOT_PERMITTED_EXT"), |
| std::make_pair(1000255000, "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"), |
| std::make_pair(1000268000, "VK_THREAD_IDLE_KHR"), |
| std::make_pair(1000268001, "VK_THREAD_DONE_KHR"), |
| std::make_pair(1000268002, "VK_OPERATION_DEFERRED_KHR"), |
| std::make_pair(1000268003, "VK_OPERATION_NOT_DEFERRED_KHR"), |
| std::make_pair(1000297000, "VK_PIPELINE_COMPILE_REQUIRED_EXT"), |
| }; |
| static void print_VkResult(VkResult obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkResult_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkResult_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkResult(const VkResult * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkResult_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkResult_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkStructureType_map = { |
| std::make_pair(0, "VK_STRUCTURE_TYPE_APPLICATION_INFO"), |
| std::make_pair(1, "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"), |
| std::make_pair(2, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO"), |
| std::make_pair(3, "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"), |
| std::make_pair(4, "VK_STRUCTURE_TYPE_SUBMIT_INFO"), |
| std::make_pair(5, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"), |
| std::make_pair(6, "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE"), |
| std::make_pair(8, "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"), |
| std::make_pair(9, "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"), |
| std::make_pair(10, "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO"), |
| std::make_pair(11, "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"), |
| std::make_pair(12, "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO"), |
| std::make_pair(13, "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"), |
| std::make_pair(14, "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"), |
| std::make_pair(15, "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"), |
| std::make_pair(17, "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO"), |
| std::make_pair(18, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"), |
| std::make_pair(19, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"), |
| std::make_pair(20, "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"), |
| std::make_pair(21, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"), |
| std::make_pair(22, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"), |
| std::make_pair(23, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO"), |
| std::make_pair(24, "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"), |
| std::make_pair(25, "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"), |
| std::make_pair(26, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"), |
| std::make_pair(27, "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO"), |
| std::make_pair(28, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"), |
| std::make_pair(29, "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"), |
| std::make_pair(30, "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO"), |
| std::make_pair(31, "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"), |
| std::make_pair(32, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"), |
| std::make_pair(33, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO"), |
| std::make_pair(34, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"), |
| std::make_pair(35, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET"), |
| std::make_pair(36, "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET"), |
| std::make_pair(37, "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"), |
| std::make_pair(38, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"), |
| std::make_pair(39, "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO"), |
| std::make_pair(40, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"), |
| std::make_pair(41, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO"), |
| std::make_pair(42, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"), |
| std::make_pair(43, "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"), |
| std::make_pair(44, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"), |
| std::make_pair(45, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"), |
| std::make_pair(46, "VK_STRUCTURE_TYPE_MEMORY_BARRIER"), |
| std::make_pair(47, "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"), |
| std::make_pair(48, "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"), |
| std::make_pair(1000094000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"), |
| std::make_pair(1000157000, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"), |
| std::make_pair(1000157001, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"), |
| std::make_pair(1000083000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"), |
| std::make_pair(1000127000, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"), |
| std::make_pair(1000127001, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"), |
| std::make_pair(1000060000, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"), |
| std::make_pair(1000060003, "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"), |
| std::make_pair(1000060004, "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"), |
| std::make_pair(1000060005, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"), |
| std::make_pair(1000060013, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"), |
| std::make_pair(1000060014, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"), |
| std::make_pair(1000070000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"), |
| std::make_pair(1000070001, "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"), |
| std::make_pair(1000146000, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"), |
| std::make_pair(1000146001, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"), |
| std::make_pair(1000146003, "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"), |
| std::make_pair(1000059000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"), |
| std::make_pair(1000059001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"), |
| std::make_pair(1000059002, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"), |
| std::make_pair(1000059003, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"), |
| std::make_pair(1000059004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"), |
| std::make_pair(1000059005, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"), |
| std::make_pair(1000059006, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"), |
| std::make_pair(1000117000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"), |
| std::make_pair(1000117001, "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"), |
| std::make_pair(1000117002, "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"), |
| std::make_pair(1000117003, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"), |
| std::make_pair(1000053000, "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"), |
| std::make_pair(1000053001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"), |
| std::make_pair(1000053002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"), |
| std::make_pair(1000120000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"), |
| std::make_pair(1000145000, "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO"), |
| std::make_pair(1000145001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"), |
| std::make_pair(1000145002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"), |
| std::make_pair(1000145003, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2"), |
| std::make_pair(1000156000, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"), |
| std::make_pair(1000156001, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"), |
| std::make_pair(1000156002, "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"), |
| std::make_pair(1000156003, "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"), |
| std::make_pair(1000156004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"), |
| std::make_pair(1000156005, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"), |
| std::make_pair(1000071000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"), |
| std::make_pair(1000071001, "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"), |
| std::make_pair(1000071002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"), |
| std::make_pair(1000071003, "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"), |
| std::make_pair(1000071004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"), |
| std::make_pair(1000072000, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"), |
| std::make_pair(1000072001, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"), |
| std::make_pair(1000072002, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"), |
| std::make_pair(1000112000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"), |
| std::make_pair(1000112001, "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"), |
| std::make_pair(1000113000, "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"), |
| std::make_pair(1000077000, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"), |
| std::make_pair(1000076000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"), |
| std::make_pair(1000076001, "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"), |
| std::make_pair(1000168000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"), |
| std::make_pair(1000168001, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"), |
| std::make_pair(1000063000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"), |
| std::make_pair(49, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"), |
| std::make_pair(50, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"), |
| std::make_pair(51, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"), |
| std::make_pair(52, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"), |
| std::make_pair(1000147000, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"), |
| std::make_pair(1000109000, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"), |
| std::make_pair(1000109001, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"), |
| std::make_pair(1000109002, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"), |
| std::make_pair(1000109003, "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"), |
| std::make_pair(1000109004, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"), |
| std::make_pair(1000109005, "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"), |
| std::make_pair(1000109006, "VK_STRUCTURE_TYPE_SUBPASS_END_INFO"), |
| std::make_pair(1000177000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"), |
| std::make_pair(1000196000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"), |
| std::make_pair(1000180000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"), |
| std::make_pair(1000082000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"), |
| std::make_pair(1000197000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"), |
| std::make_pair(1000161000, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"), |
| std::make_pair(1000161001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"), |
| std::make_pair(1000161002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"), |
| std::make_pair(1000161003, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"), |
| std::make_pair(1000161004, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"), |
| std::make_pair(1000199000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"), |
| std::make_pair(1000199001, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"), |
| std::make_pair(1000221000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"), |
| std::make_pair(1000246000, "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"), |
| std::make_pair(1000130000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"), |
| std::make_pair(1000130001, "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"), |
| std::make_pair(1000211000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"), |
| std::make_pair(1000108000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"), |
| std::make_pair(1000108001, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"), |
| std::make_pair(1000108002, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"), |
| std::make_pair(1000108003, "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"), |
| std::make_pair(1000253000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"), |
| std::make_pair(1000175000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"), |
| std::make_pair(1000241000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"), |
| std::make_pair(1000241001, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"), |
| std::make_pair(1000241002, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"), |
| std::make_pair(1000261000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"), |
| std::make_pair(1000207000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"), |
| std::make_pair(1000207001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"), |
| std::make_pair(1000207002, "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"), |
| std::make_pair(1000207003, "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"), |
| std::make_pair(1000207004, "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"), |
| std::make_pair(1000207005, "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"), |
| std::make_pair(1000257000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"), |
| std::make_pair(1000244001, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"), |
| std::make_pair(1000257002, "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"), |
| std::make_pair(1000257003, "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"), |
| std::make_pair(1000257004, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"), |
| std::make_pair(1000298000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES"), |
| std::make_pair(1000298001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES"), |
| std::make_pair(1000298002, "VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO"), |
| std::make_pair(1000298003, "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO"), |
| std::make_pair(1000298004, "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION"), |
| std::make_pair(1000298005, "VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE"), |
| std::make_pair(1000298007, "VK_STRUCTURE_TYPE_FAULT_DATA"), |
| std::make_pair(1000298008, "VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO"), |
| std::make_pair(1000298010, "VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO"), |
| std::make_pair(1000001000, "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"), |
| std::make_pair(1000001001, "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"), |
| std::make_pair(1000060007, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"), |
| std::make_pair(1000060008, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), |
| std::make_pair(1000060009, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"), |
| std::make_pair(1000060010, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"), |
| std::make_pair(1000060011, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"), |
| std::make_pair(1000060012, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"), |
| std::make_pair(1000002000, "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR"), |
| std::make_pair(1000002001, "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR"), |
| std::make_pair(1000003000, "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR"), |
| std::make_pair(1000004000, "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR"), |
| std::make_pair(1000005000, "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR"), |
| std::make_pair(1000006000, "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR"), |
| std::make_pair(1000008000, "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR"), |
| std::make_pair(1000009000, "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR"), |
| std::make_pair(1000010000, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"), |
| std::make_pair(1000010001, "VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID"), |
| std::make_pair(1000010002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID"), |
| std::make_pair(1000011000, "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"), |
| std::make_pair(1000018000, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"), |
| std::make_pair(1000022000, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"), |
| std::make_pair(1000022001, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"), |
| std::make_pair(1000022002, "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT"), |
| std::make_pair(1000023000, "VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR"), |
| std::make_pair(1000023001, "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR"), |
| std::make_pair(1000023002, "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR"), |
| std::make_pair(1000023003, "VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR"), |
| std::make_pair(1000023004, "VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR"), |
| std::make_pair(1000023005, "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR"), |
| std::make_pair(1000023006, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR"), |
| std::make_pair(1000023007, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR"), |
| std::make_pair(1000023008, "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR"), |
| std::make_pair(1000023009, "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR"), |
| std::make_pair(1000023010, "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR"), |
| std::make_pair(1000023011, "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR"), |
| std::make_pair(1000023012, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR"), |
| std::make_pair(1000023013, "VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR"), |
| std::make_pair(1000023014, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR"), |
| std::make_pair(1000023015, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR"), |
| std::make_pair(1000024000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR"), |
| std::make_pair(1000026000, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV"), |
| std::make_pair(1000026001, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV"), |
| std::make_pair(1000026002, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV"), |
| std::make_pair(1000028000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT"), |
| std::make_pair(1000028001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT"), |
| std::make_pair(1000028002, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"), |
| std::make_pair(1000029000, "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX"), |
| std::make_pair(1000029001, "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX"), |
| std::make_pair(1000029002, "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"), |
| std::make_pair(1000030000, "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"), |
| std::make_pair(1000030001, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"), |
| std::make_pair(1000038000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"), |
| std::make_pair(1000038001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT"), |
| std::make_pair(1000038002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"), |
| std::make_pair(1000038003, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"), |
| std::make_pair(1000038004, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT"), |
| std::make_pair(1000038005, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"), |
| std::make_pair(1000038006, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT"), |
| std::make_pair(1000038007, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT"), |
| std::make_pair(1000038008, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT"), |
| std::make_pair(1000038009, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT"), |
| std::make_pair(1000038010, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT"), |
| std::make_pair(1000039000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"), |
| std::make_pair(1000039001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT"), |
| std::make_pair(1000039002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"), |
| std::make_pair(1000039003, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"), |
| std::make_pair(1000039004, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT"), |
| std::make_pair(1000039005, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"), |
| std::make_pair(1000039006, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT"), |
| std::make_pair(1000039007, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT"), |
| std::make_pair(1000039008, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT"), |
| std::make_pair(1000039009, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT"), |
| std::make_pair(1000039010, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT"), |
| std::make_pair(1000039011, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT"), |
| std::make_pair(1000040000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR"), |
| std::make_pair(1000040001, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT"), |
| std::make_pair(1000040002, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR"), |
| std::make_pair(1000040003, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT"), |
| std::make_pair(1000040004, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT"), |
| std::make_pair(1000040005, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"), |
| std::make_pair(1000040006, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR"), |
| std::make_pair(1000040007, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR"), |
| std::make_pair(1000041000, "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"), |
| std::make_pair(1000044000, "VK_STRUCTURE_TYPE_RENDERING_INFO_KHR"), |
| std::make_pair(1000044001, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR"), |
| std::make_pair(1000044002, "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR"), |
| std::make_pair(1000044003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR"), |
| std::make_pair(1000044004, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR"), |
| std::make_pair(1000044006, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"), |
| std::make_pair(1000044007, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT"), |
| std::make_pair(1000044008, "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD"), |
| std::make_pair(1000044009, "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"), |
| std::make_pair(1000049000, "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP"), |
| std::make_pair(1000050000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"), |
| std::make_pair(1000051000, "VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_RESERVED_OFFSET_0_NV"), |
| std::make_pair(1000056000, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV"), |
| std::make_pair(1000056001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV"), |
| std::make_pair(1000057000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"), |
| std::make_pair(1000057001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"), |
| std::make_pair(1000058000, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"), |
| std::make_pair(1000060007, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"), |
| std::make_pair(1000060008, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), |
| std::make_pair(1000060009, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"), |
| std::make_pair(1000060010, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"), |
| std::make_pair(1000060011, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"), |
| std::make_pair(1000060012, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"), |
| std::make_pair(1000061000, "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT"), |
| std::make_pair(1000062000, "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN"), |
| std::make_pair(1000066000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"), |
| std::make_pair(1000067000, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"), |
| std::make_pair(1000067001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"), |
| std::make_pair(1000073000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000073001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000073002, "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"), |
| std::make_pair(1000073003, "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000074000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"), |
| std::make_pair(1000074001, "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR"), |
| std::make_pair(1000074002, "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"), |
| std::make_pair(1000075000, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"), |
| std::make_pair(1000078000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000078001, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000078002, "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"), |
| std::make_pair(1000078003, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000079000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"), |
| std::make_pair(1000079001, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"), |
| std::make_pair(1000080000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"), |
| std::make_pair(1000081000, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"), |
| std::make_pair(1000081001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"), |
| std::make_pair(1000081002, "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT"), |
| std::make_pair(1000084000, "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR"), |
| std::make_pair(1000087000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000090000, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT"), |
| std::make_pair(1000091000, "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT"), |
| std::make_pair(1000091001, "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT"), |
| std::make_pair(1000091002, "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT"), |
| std::make_pair(1000091003, "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT"), |
| std::make_pair(1000092000, "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE"), |
| std::make_pair(1000097000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"), |
| std::make_pair(1000098000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000099000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"), |
| std::make_pair(1000099001, "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"), |
| std::make_pair(1000101000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT"), |
| std::make_pair(1000101001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"), |
| std::make_pair(1000102000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"), |
| std::make_pair(1000102001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"), |
| std::make_pair(1000105000, "VK_STRUCTURE_TYPE_HDR_METADATA_EXT"), |
| std::make_pair(1000111000, "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"), |
| std::make_pair(1000114000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000114001, "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000114002, "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"), |
| std::make_pair(1000115000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"), |
| std::make_pair(1000115001, "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"), |
| std::make_pair(1000116000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"), |
| std::make_pair(1000116001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"), |
| std::make_pair(1000116002, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"), |
| std::make_pair(1000116003, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"), |
| std::make_pair(1000116004, "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"), |
| std::make_pair(1000116005, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"), |
| std::make_pair(1000116006, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"), |
| std::make_pair(1000116007, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR"), |
| std::make_pair(1000119000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"), |
| std::make_pair(1000119001, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR"), |
| std::make_pair(1000119002, "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR"), |
| std::make_pair(1000121000, "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR"), |
| std::make_pair(1000121001, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR"), |
| std::make_pair(1000121002, "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR"), |
| std::make_pair(1000121003, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR"), |
| std::make_pair(1000121004, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR"), |
| std::make_pair(1000122000, "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"), |
| std::make_pair(1000123000, "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"), |
| std::make_pair(1000128000, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"), |
| std::make_pair(1000128001, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT"), |
| std::make_pair(1000128002, "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT"), |
| std::make_pair(1000128003, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"), |
| std::make_pair(1000128004, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"), |
| std::make_pair(1000129000, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID"), |
| std::make_pair(1000129001, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID"), |
| std::make_pair(1000129002, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID"), |
| std::make_pair(1000129003, "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"), |
| std::make_pair(1000129004, "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"), |
| std::make_pair(1000129005, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"), |
| std::make_pair(1000129006, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"), |
| std::make_pair(1000138000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT"), |
| std::make_pair(1000138001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT"), |
| std::make_pair(1000138002, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT"), |
| std::make_pair(1000138003, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT"), |
| std::make_pair(1000143000, "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"), |
| std::make_pair(1000143001, "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"), |
| std::make_pair(1000143002, "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"), |
| std::make_pair(1000143003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT"), |
| std::make_pair(1000143004, "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT"), |
| std::make_pair(1000148000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"), |
| std::make_pair(1000148001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"), |
| std::make_pair(1000148002, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"), |
| std::make_pair(1000149000, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000150007, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR"), |
| std::make_pair(1000150000, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR"), |
| std::make_pair(1000150002, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR"), |
| std::make_pair(1000150003, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR"), |
| std::make_pair(1000150004, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR"), |
| std::make_pair(1000150005, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR"), |
| std::make_pair(1000150006, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR"), |
| std::make_pair(1000150009, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR"), |
| std::make_pair(1000150010, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR"), |
| std::make_pair(1000150011, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR"), |
| std::make_pair(1000150012, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR"), |
| std::make_pair(1000150013, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR"), |
| std::make_pair(1000150014, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR"), |
| std::make_pair(1000150017, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR"), |
| std::make_pair(1000150020, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"), |
| std::make_pair(1000347000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR"), |
| std::make_pair(1000347001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR"), |
| std::make_pair(1000150015, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR"), |
| std::make_pair(1000150016, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR"), |
| std::make_pair(1000150018, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR"), |
| std::make_pair(1000348013, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR"), |
| std::make_pair(1000152000, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000154000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV"), |
| std::make_pair(1000154001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"), |
| std::make_pair(1000158000, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT"), |
| std::make_pair(1000158002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT"), |
| std::make_pair(1000158003, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT"), |
| std::make_pair(1000158004, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT"), |
| std::make_pair(1000158005, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT"), |
| std::make_pair(1000158006, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT"), |
| std::make_pair(1000160000, "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT"), |
| std::make_pair(1000160001, "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT"), |
| std::make_pair(1000163000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR"), |
| std::make_pair(1000163001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR"), |
| std::make_pair(1000164000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000164001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"), |
| std::make_pair(1000164002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"), |
| std::make_pair(1000164005, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000165000, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV"), |
| std::make_pair(1000165001, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV"), |
| std::make_pair(1000165003, "VK_STRUCTURE_TYPE_GEOMETRY_NV"), |
| std::make_pair(1000165004, "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV"), |
| std::make_pair(1000165005, "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV"), |
| std::make_pair(1000165006, "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV"), |
| std::make_pair(1000165007, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV"), |
| std::make_pair(1000165008, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV"), |
| std::make_pair(1000165009, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV"), |
| std::make_pair(1000165011, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV"), |
| std::make_pair(1000165012, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV"), |
| std::make_pair(1000166000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"), |
| std::make_pair(1000166001, "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000170000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT"), |
| std::make_pair(1000170001, "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"), |
| std::make_pair(1000174000, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT"), |
| std::make_pair(1000178000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT"), |
| std::make_pair(1000178001, "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT"), |
| std::make_pair(1000178002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"), |
| std::make_pair(1000181000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"), |
| std::make_pair(1000183000, "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"), |
| std::make_pair(1000184000, "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"), |
| std::make_pair(1000185000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"), |
| std::make_pair(1000187000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT"), |
| std::make_pair(1000187001, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT"), |
| std::make_pair(1000187002, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"), |
| std::make_pair(1000187003, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"), |
| std::make_pair(1000187004, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT"), |
| std::make_pair(1000187005, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT"), |
| std::make_pair(1000187006, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT"), |
| std::make_pair(1000189000, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"), |
| std::make_pair(1000190000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"), |
| std::make_pair(1000190001, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"), |
| std::make_pair(1000190002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"), |
| std::make_pair(1000191000, "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"), |
| std::make_pair(1000192000, "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT"), |
| std::make_pair(1000201000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"), |
| std::make_pair(1000202000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"), |
| std::make_pair(1000202001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"), |
| std::make_pair(1000203000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"), |
| std::make_pair(1000204000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"), |
| std::make_pair(1000205000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000205002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"), |
| std::make_pair(1000206000, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV"), |
| std::make_pair(1000206001, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"), |
| std::make_pair(1000209000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"), |
| std::make_pair(1000210000, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL"), |
| std::make_pair(1000210001, "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL"), |
| std::make_pair(1000210002, "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL"), |
| std::make_pair(1000210003, "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL"), |
| std::make_pair(1000210004, "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL"), |
| std::make_pair(1000210005, "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL"), |
| std::make_pair(1000212000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"), |
| std::make_pair(1000213000, "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD"), |
| std::make_pair(1000213001, "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD"), |
| std::make_pair(1000214000, "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA"), |
| std::make_pair(1000215000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR"), |
| std::make_pair(1000217000, "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT"), |
| std::make_pair(1000218000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT"), |
| std::make_pair(1000218001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"), |
| std::make_pair(1000218002, "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"), |
| std::make_pair(1000225000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"), |
| std::make_pair(1000225001, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"), |
| std::make_pair(1000225002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"), |
| std::make_pair(1000226000, "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"), |
| std::make_pair(1000226001, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR"), |
| std::make_pair(1000226002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR"), |
| std::make_pair(1000226003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR"), |
| std::make_pair(1000226004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"), |
| std::make_pair(1000227000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"), |
| std::make_pair(1000229000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"), |
| std::make_pair(1000234000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"), |
| std::make_pair(1000237000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"), |
| std::make_pair(1000238000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"), |
| std::make_pair(1000238001, "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"), |
| std::make_pair(1000239000, "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR"), |
| std::make_pair(1000240000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV"), |
| std::make_pair(1000244000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"), |
| std::make_pair(1000244002, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"), |
| std::make_pair(1000245000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT"), |
| std::make_pair(1000247000, "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"), |
| std::make_pair(1000248000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"), |
| std::make_pair(1000249000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"), |
| std::make_pair(1000249001, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV"), |
| std::make_pair(1000249002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV"), |
| std::make_pair(1000250000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV"), |
| std::make_pair(1000250001, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000250002, "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV"), |
| std::make_pair(1000251000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"), |
| std::make_pair(1000252000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT"), |
| std::make_pair(1000254000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT"), |
| std::make_pair(1000254001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"), |
| std::make_pair(1000254002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"), |
| std::make_pair(1000255000, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"), |
| std::make_pair(1000255002, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"), |
| std::make_pair(1000255001, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT"), |
| std::make_pair(1000256000, "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT"), |
| std::make_pair(1000259000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"), |
| std::make_pair(1000259001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"), |
| std::make_pair(1000259002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"), |
| std::make_pair(1000260000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"), |
| std::make_pair(1000265000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"), |
| std::make_pair(1000267000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT"), |
| std::make_pair(1000269000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"), |
| std::make_pair(1000269001, "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"), |
| std::make_pair(1000269002, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"), |
| std::make_pair(1000269003, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"), |
| std::make_pair(1000269004, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"), |
| std::make_pair(1000269005, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"), |
| std::make_pair(1000273000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"), |
| std::make_pair(1000276000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT"), |
| std::make_pair(1000277000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV"), |
| std::make_pair(1000277001, "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV"), |
| std::make_pair(1000277002, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV"), |
| std::make_pair(1000277003, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"), |
| std::make_pair(1000277004, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"), |
| std::make_pair(1000277005, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV"), |
| std::make_pair(1000277006, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV"), |
| std::make_pair(1000277007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV"), |
| std::make_pair(1000278000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"), |
| std::make_pair(1000278001, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"), |
| std::make_pair(1000280000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR"), |
| std::make_pair(1000280001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR"), |
| std::make_pair(1000281000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT"), |
| std::make_pair(1000281001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT"), |
| std::make_pair(1000282000, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM"), |
| std::make_pair(1000282001, "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"), |
| std::make_pair(1000284000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT"), |
| std::make_pair(1000284001, "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT"), |
| std::make_pair(1000284002, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT"), |
| std::make_pair(1000286000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"), |
| std::make_pair(1000286001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"), |
| std::make_pair(1000287000, "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT"), |
| std::make_pair(1000287001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT"), |
| std::make_pair(1000287002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT"), |
| std::make_pair(1000290000, "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR"), |
| std::make_pair(1000294000, "VK_STRUCTURE_TYPE_PRESENT_ID_KHR"), |
| std::make_pair(1000294001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"), |
| std::make_pair(1000295000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT"), |
| std::make_pair(1000295001, "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT"), |
| std::make_pair(1000295002, "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT"), |
| std::make_pair(1000297000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT"), |
| std::make_pair(1000299000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR"), |
| std::make_pair(1000299001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"), |
| std::make_pair(1000299002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR"), |
| std::make_pair(1000300000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"), |
| std::make_pair(1000300001, "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"), |
| std::make_pair(1000308000, "VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR"), |
| std::make_pair(1000309000, "VK_STRUCTURE_TYPE_RESERVED_QCOM"), |
| std::make_pair(1000314000, "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR"), |
| std::make_pair(1000314001, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR"), |
| std::make_pair(1000314002, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR"), |
| std::make_pair(1000314003, "VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR"), |
| std::make_pair(1000314004, "VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR"), |
| std::make_pair(1000314005, "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR"), |
| std::make_pair(1000314006, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR"), |
| std::make_pair(1000314007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR"), |
| std::make_pair(1000314008, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"), |
| std::make_pair(1000314009, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV"), |
| std::make_pair(1000323000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR"), |
| std::make_pair(1000325000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"), |
| std::make_pair(1000326000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"), |
| std::make_pair(1000326001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV"), |
| std::make_pair(1000326002, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV"), |
| std::make_pair(1000327000, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"), |
| std::make_pair(1000327001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"), |
| std::make_pair(1000327002, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV"), |
| std::make_pair(1000330000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"), |
| std::make_pair(1000332000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT"), |
| std::make_pair(1000332001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"), |
| std::make_pair(1000333000, "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM"), |
| std::make_pair(1000335000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT"), |
| std::make_pair(1000336000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"), |
| std::make_pair(1000337000, "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR"), |
| std::make_pair(1000337001, "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR"), |
| std::make_pair(1000337002, "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR"), |
| std::make_pair(1000337003, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR"), |
| std::make_pair(1000337004, "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR"), |
| std::make_pair(1000337005, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR"), |
| std::make_pair(1000337006, "VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR"), |
| std::make_pair(1000337007, "VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR"), |
| std::make_pair(1000337008, "VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR"), |
| std::make_pair(1000337009, "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR"), |
| std::make_pair(1000337010, "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR"), |
| std::make_pair(1000340000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"), |
| std::make_pair(1000342000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM"), |
| std::make_pair(1000344000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT"), |
| std::make_pair(1000346000, "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT"), |
| std::make_pair(1000351000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"), |
| std::make_pair(1000351002, "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"), |
| std::make_pair(1000352000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT"), |
| std::make_pair(1000352001, "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT"), |
| std::make_pair(1000352002, "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT"), |
| std::make_pair(1000353000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"), |
| std::make_pair(1000355000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT"), |
| std::make_pair(1000355001, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT"), |
| std::make_pair(1000356000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT"), |
| std::make_pair(1000360000, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR"), |
| std::make_pair(1000364000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"), |
| std::make_pair(1000364001, "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"), |
| std::make_pair(1000364002, "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"), |
| std::make_pair(1000365000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"), |
| std::make_pair(1000365001, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"), |
| std::make_pair(1000366000, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"), |
| std::make_pair(1000366001, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA"), |
| std::make_pair(1000366002, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"), |
| std::make_pair(1000366003, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"), |
| std::make_pair(1000366004, "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA"), |
| std::make_pair(1000366005, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"), |
| std::make_pair(1000366006, "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA"), |
| std::make_pair(1000366007, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"), |
| std::make_pair(1000366008, "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA"), |
| std::make_pair(1000366009, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA"), |
| std::make_pair(1000369000, "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI"), |
| std::make_pair(1000369001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI"), |
| std::make_pair(1000369002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI"), |
| std::make_pair(1000370000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI"), |
| std::make_pair(1000371000, "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"), |
| std::make_pair(1000371001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV"), |
| std::make_pair(1000373000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373001, "VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373002, "VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373003, "VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV"), |
| std::make_pair(1000373004, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373005, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373006, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV"), |
| std::make_pair(1000374000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV"), |
| std::make_pair(1000374001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV"), |
| std::make_pair(1000374002, "VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV"), |
| std::make_pair(1000374003, "VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV"), |
| std::make_pair(1000374004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV"), |
| std::make_pair(1000377000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"), |
| std::make_pair(1000378000, "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX"), |
| std::make_pair(1000381000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT"), |
| std::make_pair(1000381001, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT"), |
| std::make_pair(1000388000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT"), |
| std::make_pair(1000388001, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT"), |
| std::make_pair(1000391000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT"), |
| std::make_pair(1000391001, "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"), |
| std::make_pair(1000392000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT"), |
| std::make_pair(1000392001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT"), |
| std::make_pair(1000411000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"), |
| std::make_pair(1000411001, "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"), |
| std::make_pair(1000412000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"), |
| std::make_pair(1000413000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR"), |
| std::make_pair(1000413001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR"), |
| std::make_pair(1000413002, "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR"), |
| std::make_pair(1000413003, "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR"), |
| std::make_pair(1000435000, "VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT"), |
| std::make_pair(1000489000, "VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV"), |
| std::make_pair(1000489001, "VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV"), |
| std::make_pair(1000489002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV"), |
| std::make_pair(1000373000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373001, "VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373002, "VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV"), |
| std::make_pair(1000373003, "VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV"), |
| std::make_pair(1000489003, "VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV"), |
| }; |
| static void print_VkStructureType(VkStructureType obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkStructureType_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkStructureType_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkStructureType(const VkStructureType * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkStructureType_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkStructureType_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkAccessFlagBits_map = { |
| std::make_pair(1ULL << 0, "VK_ACCESS_INDIRECT_COMMAND_READ_BIT"), |
| std::make_pair(1ULL << 1, "VK_ACCESS_INDEX_READ_BIT"), |
| std::make_pair(1ULL << 2, "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"), |
| std::make_pair(1ULL << 3, "VK_ACCESS_UNIFORM_READ_BIT"), |
| std::make_pair(1ULL << 4, "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"), |
| std::make_pair(1ULL << 5, "VK_ACCESS_SHADER_READ_BIT"), |
| std::make_pair(1ULL << 6, "VK_ACCESS_SHADER_WRITE_BIT"), |
| std::make_pair(1ULL << 7, "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"), |
| std::make_pair(1ULL << 8, "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"), |
| std::make_pair(1ULL << 9, "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"), |
| std::make_pair(1ULL << 10, "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"), |
| std::make_pair(1ULL << 11, "VK_ACCESS_TRANSFER_READ_BIT"), |
| std::make_pair(1ULL << 12, "VK_ACCESS_TRANSFER_WRITE_BIT"), |
| std::make_pair(1ULL << 13, "VK_ACCESS_HOST_READ_BIT"), |
| std::make_pair(1ULL << 14, "VK_ACCESS_HOST_WRITE_BIT"), |
| std::make_pair(1ULL << 15, "VK_ACCESS_MEMORY_READ_BIT"), |
| std::make_pair(1ULL << 16, "VK_ACCESS_MEMORY_WRITE_BIT"), |
| std::make_pair(1ULL << 25, "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"), |
| std::make_pair(1ULL << 26, "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"), |
| std::make_pair(1ULL << 27, "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"), |
| std::make_pair(1ULL << 20, "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT"), |
| std::make_pair(1ULL << 19, "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"), |
| std::make_pair(1ULL << 21, "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"), |
| std::make_pair(1ULL << 22, "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"), |
| std::make_pair(1ULL << 24, "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"), |
| std::make_pair(1ULL << 23, "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"), |
| std::make_pair(1ULL << 17, "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV"), |
| std::make_pair(1ULL << 18, "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV"), |
| std::make_pair(0, "VK_ACCESS_NONE_KHR"), |
| }; |
| static void print_VkAccessFlagBits(VkAccessFlagBits obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkAccessFlagBits_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkAccessFlagBits_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkAccessFlagBits(const VkAccessFlagBits * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkAccessFlagBits_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkAccessFlagBits_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkImageLayout_map = { |
| std::make_pair(0, "VK_IMAGE_LAYOUT_UNDEFINED"), |
| std::make_pair(1, "VK_IMAGE_LAYOUT_GENERAL"), |
| std::make_pair(2, "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"), |
| std::make_pair(3, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), |
| std::make_pair(4, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"), |
| std::make_pair(5, "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"), |
| std::make_pair(6, "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL"), |
| std::make_pair(7, "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL"), |
| std::make_pair(8, "VK_IMAGE_LAYOUT_PREINITIALIZED"), |
| std::make_pair(1000117000, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"), |
| std::make_pair(1000117001, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"), |
| std::make_pair(1000241000, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"), |
| std::make_pair(1000241001, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"), |
| std::make_pair(1000241002, "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"), |
| std::make_pair(1000241003, "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"), |
| std::make_pair(1000001002, "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR"), |
| std::make_pair(1000024000, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR"), |
| std::make_pair(1000024001, "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR"), |
| std::make_pair(1000024002, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR"), |
| std::make_pair(1000111000, "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR"), |
| std::make_pair(1000218000, "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), |
| std::make_pair(1000164003, "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"), |
| std::make_pair(1000299000, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR"), |
| std::make_pair(1000299001, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR"), |
| std::make_pair(1000299002, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"), |
| std::make_pair(1000314000, "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR"), |
| std::make_pair(1000314001, "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR"), |
| }; |
| static void print_VkImageLayout(VkImageLayout obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkImageLayout_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkImageLayout_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkImageLayout(const VkImageLayout * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkImageLayout_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkImageLayout_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkImageAspectFlagBits_map = { |
| std::make_pair(1ULL << 0, "VK_IMAGE_ASPECT_COLOR_BIT"), |
| std::make_pair(1ULL << 1, "VK_IMAGE_ASPECT_DEPTH_BIT"), |
| std::make_pair(1ULL << 2, "VK_IMAGE_ASPECT_STENCIL_BIT"), |
| std::make_pair(1ULL << 3, "VK_IMAGE_ASPECT_METADATA_BIT"), |
| std::make_pair(1ULL << 4, "VK_IMAGE_ASPECT_PLANE_0_BIT"), |
| std::make_pair(1ULL << 5, "VK_IMAGE_ASPECT_PLANE_1_BIT"), |
| std::make_pair(1ULL << 6, "VK_IMAGE_ASPECT_PLANE_2_BIT"), |
| std::make_pair(1ULL << 7, "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT"), |
| std::make_pair(1ULL << 8, "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT"), |
| std::make_pair(1ULL << 9, "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT"), |
| std::make_pair(1ULL << 10, "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT"), |
| std::make_pair(0, "VK_IMAGE_ASPECT_NONE_KHR"), |
| }; |
| static void print_VkImageAspectFlagBits(VkImageAspectFlagBits obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkImageAspectFlagBits_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkImageAspectFlagBits_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkImageAspectFlagBits(const VkImageAspectFlagBits * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkImageAspectFlagBits_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkImageAspectFlagBits_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkObjectType_map = { |
| std::make_pair(0, "VK_OBJECT_TYPE_UNKNOWN"), |
| std::make_pair(1, "VK_OBJECT_TYPE_INSTANCE"), |
| std::make_pair(2, "VK_OBJECT_TYPE_PHYSICAL_DEVICE"), |
| std::make_pair(3, "VK_OBJECT_TYPE_DEVICE"), |
| std::make_pair(4, "VK_OBJECT_TYPE_QUEUE"), |
| std::make_pair(5, "VK_OBJECT_TYPE_SEMAPHORE"), |
| std::make_pair(6, "VK_OBJECT_TYPE_COMMAND_BUFFER"), |
| std::make_pair(7, "VK_OBJECT_TYPE_FENCE"), |
| std::make_pair(8, "VK_OBJECT_TYPE_DEVICE_MEMORY"), |
| std::make_pair(9, "VK_OBJECT_TYPE_BUFFER"), |
| std::make_pair(10, "VK_OBJECT_TYPE_IMAGE"), |
| std::make_pair(11, "VK_OBJECT_TYPE_EVENT"), |
| std::make_pair(12, "VK_OBJECT_TYPE_QUERY_POOL"), |
| std::make_pair(13, "VK_OBJECT_TYPE_BUFFER_VIEW"), |
| std::make_pair(14, "VK_OBJECT_TYPE_IMAGE_VIEW"), |
| std::make_pair(15, "VK_OBJECT_TYPE_SHADER_MODULE"), |
| std::make_pair(16, "VK_OBJECT_TYPE_PIPELINE_CACHE"), |
| std::make_pair(17, "VK_OBJECT_TYPE_PIPELINE_LAYOUT"), |
| std::make_pair(18, "VK_OBJECT_TYPE_RENDER_PASS"), |
| std::make_pair(19, "VK_OBJECT_TYPE_PIPELINE"), |
| std::make_pair(20, "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"), |
| std::make_pair(21, "VK_OBJECT_TYPE_SAMPLER"), |
| std::make_pair(22, "VK_OBJECT_TYPE_DESCRIPTOR_POOL"), |
| std::make_pair(23, "VK_OBJECT_TYPE_DESCRIPTOR_SET"), |
| std::make_pair(24, "VK_OBJECT_TYPE_FRAMEBUFFER"), |
| std::make_pair(25, "VK_OBJECT_TYPE_COMMAND_POOL"), |
| std::make_pair(1000156000, "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"), |
| std::make_pair(1000000000, "VK_OBJECT_TYPE_SURFACE_KHR"), |
| std::make_pair(1000001000, "VK_OBJECT_TYPE_SWAPCHAIN_KHR"), |
| std::make_pair(1000002000, "VK_OBJECT_TYPE_DISPLAY_KHR"), |
| std::make_pair(1000002001, "VK_OBJECT_TYPE_DISPLAY_MODE_KHR"), |
| std::make_pair(1000011000, "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT"), |
| std::make_pair(1000023000, "VK_OBJECT_TYPE_VIDEO_SESSION_KHR"), |
| std::make_pair(1000023001, "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR"), |
| std::make_pair(1000029000, "VK_OBJECT_TYPE_CU_MODULE_NVX"), |
| std::make_pair(1000029001, "VK_OBJECT_TYPE_CU_FUNCTION_NVX"), |
| std::make_pair(1000128000, "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT"), |
| std::make_pair(1000150000, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"), |
| std::make_pair(1000160000, "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT"), |
| std::make_pair(1000165000, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"), |
| std::make_pair(1000210000, "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL"), |
| std::make_pair(1000268000, "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR"), |
| std::make_pair(1000277000, "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"), |
| std::make_pair(1000295000, "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT"), |
| std::make_pair(1000366000, "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"), |
| std::make_pair(1000489000, "VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV"), |
| }; |
| static void print_VkObjectType(VkObjectType obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkObjectType_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkObjectType_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkObjectType(const VkObjectType * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkObjectType_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkObjectType_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkPipelineCacheHeaderVersion_map = { |
| std::make_pair(1, "VK_PIPELINE_CACHE_HEADER_VERSION_ONE"), |
| std::make_pair(1000298001, "VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE"), |
| }; |
| static void print_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkPipelineCacheHeaderVersion_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkPipelineCacheHeaderVersion_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkPipelineCacheHeaderVersion_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkPipelineCacheHeaderVersion_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkVendorId_map = { |
| std::make_pair(0x10001, "VK_VENDOR_ID_VIV"), |
| std::make_pair(0x10002, "VK_VENDOR_ID_VSI"), |
| std::make_pair(0x10003, "VK_VENDOR_ID_KAZAN"), |
| std::make_pair(0x10004, "VK_VENDOR_ID_CODEPLAY"), |
| std::make_pair(0x10005, "VK_VENDOR_ID_MESA"), |
| std::make_pair(0x10006, "VK_VENDOR_ID_POCL"), |
| }; |
| static void print_VkVendorId(VkVendorId obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkVendorId_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkVendorId_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkVendorId(const VkVendorId * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkVendorId_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkVendorId_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkSystemAllocationScope_map = { |
| std::make_pair(0, "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND"), |
| std::make_pair(1, "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT"), |
| std::make_pair(2, "VK_SYSTEM_ALLOCATION_SCOPE_CACHE"), |
| std::make_pair(3, "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE"), |
| std::make_pair(4, "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE"), |
| }; |
| static void print_VkSystemAllocationScope(VkSystemAllocationScope obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkSystemAllocationScope_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkSystemAllocationScope_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkSystemAllocationScope(const VkSystemAllocationScope * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkSystemAllocationScope_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkSystemAllocationScope_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkInternalAllocationType_map = { |
| std::make_pair(0, "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE"), |
| }; |
| static void print_VkInternalAllocationType(VkInternalAllocationType obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkInternalAllocationType_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkInternalAllocationType_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkInternalAllocationType(const VkInternalAllocationType * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkInternalAllocationType_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkInternalAllocationType_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkFormat_map = { |
| std::make_pair(0, "VK_FORMAT_UNDEFINED"), |
| std::make_pair(1, "VK_FORMAT_R4G4_UNORM_PACK8"), |
| std::make_pair(2, "VK_FORMAT_R4G4B4A4_UNORM_PACK16"), |
| std::make_pair(3, "VK_FORMAT_B4G4R4A4_UNORM_PACK16"), |
| std::make_pair(4, "VK_FORMAT_R5G6B5_UNORM_PACK16"), |
| std::make_pair(5, "VK_FORMAT_B5G6R5_UNORM_PACK16"), |
| std::make_pair(6, "VK_FORMAT_R5G5B5A1_UNORM_PACK16"), |
| std::make_pair(7, "VK_FORMAT_B5G5R5A1_UNORM_PACK16"), |
| std::make_pair(8, "VK_FORMAT_A1R5G5B5_UNORM_PACK16"), |
| std::make_pair(9, "VK_FORMAT_R8_UNORM"), |
| std::make_pair(10, "VK_FORMAT_R8_SNORM"), |
| std::make_pair(11, "VK_FORMAT_R8_USCALED"), |
| std::make_pair(12, "VK_FORMAT_R8_SSCALED"), |
| std::make_pair(13, "VK_FORMAT_R8_UINT"), |
| std::make_pair(14, "VK_FORMAT_R8_SINT"), |
| std::make_pair(15, "VK_FORMAT_R8_SRGB"), |
| std::make_pair(16, "VK_FORMAT_R8G8_UNORM"), |
| std::make_pair(17, "VK_FORMAT_R8G8_SNORM"), |
| std::make_pair(18, "VK_FORMAT_R8G8_USCALED"), |
| std::make_pair(19, "VK_FORMAT_R8G8_SSCALED"), |
| std::make_pair(20, "VK_FORMAT_R8G8_UINT"), |
| std::make_pair(21, "VK_FORMAT_R8G8_SINT"), |
| std::make_pair(22, "VK_FORMAT_R8G8_SRGB"), |
| std::make_pair(23, "VK_FORMAT_R8G8B8_UNORM"), |
| std::make_pair(24, "VK_FORMAT_R8G8B8_SNORM"), |
| std::make_pair(25, "VK_FORMAT_R8G8B8_USCALED"), |
| std::make_pair(26, "VK_FORMAT_R8G8B8_SSCALED"), |
| std::make_pair(27, "VK_FORMAT_R8G8B8_UINT"), |
| std::make_pair(28, "VK_FORMAT_R8G8B8_SINT"), |
| std::make_pair(29, "VK_FORMAT_R8G8B8_SRGB"), |
| std::make_pair(30, "VK_FORMAT_B8G8R8_UNORM"), |
| std::make_pair(31, "VK_FORMAT_B8G8R8_SNORM"), |
| std::make_pair(32, "VK_FORMAT_B8G8R8_USCALED"), |
| std::make_pair(33, "VK_FORMAT_B8G8R8_SSCALED"), |
| std::make_pair(34, "VK_FORMAT_B8G8R8_UINT"), |
| std::make_pair(35, "VK_FORMAT_B8G8R8_SINT"), |
| std::make_pair(36, "VK_FORMAT_B8G8R8_SRGB"), |
| std::make_pair(37, "VK_FORMAT_R8G8B8A8_UNORM"), |
| std::make_pair(38, "VK_FORMAT_R8G8B8A8_SNORM"), |
| std::make_pair(39, "VK_FORMAT_R8G8B8A8_USCALED"), |
| std::make_pair(40, "VK_FORMAT_R8G8B8A8_SSCALED"), |
| std::make_pair(41, "VK_FORMAT_R8G8B8A8_UINT"), |
| std::make_pair(42, "VK_FORMAT_R8G8B8A8_SINT"), |
| std::make_pair(43, "VK_FORMAT_R8G8B8A8_SRGB"), |
| std::make_pair(44, "VK_FORMAT_B8G8R8A8_UNORM"), |
| std::make_pair(45, "VK_FORMAT_B8G8R8A8_SNORM"), |
| std::make_pair(46, "VK_FORMAT_B8G8R8A8_USCALED"), |
| std::make_pair(47, "VK_FORMAT_B8G8R8A8_SSCALED"), |
| std::make_pair(48, "VK_FORMAT_B8G8R8A8_UINT"), |
| std::make_pair(49, "VK_FORMAT_B8G8R8A8_SINT"), |
| std::make_pair(50, "VK_FORMAT_B8G8R8A8_SRGB"), |
| std::make_pair(51, "VK_FORMAT_A8B8G8R8_UNORM_PACK32"), |
| std::make_pair(52, "VK_FORMAT_A8B8G8R8_SNORM_PACK32"), |
| std::make_pair(53, "VK_FORMAT_A8B8G8R8_USCALED_PACK32"), |
| std::make_pair(54, "VK_FORMAT_A8B8G8R8_SSCALED_PACK32"), |
| std::make_pair(55, "VK_FORMAT_A8B8G8R8_UINT_PACK32"), |
| std::make_pair(56, "VK_FORMAT_A8B8G8R8_SINT_PACK32"), |
| std::make_pair(57, "VK_FORMAT_A8B8G8R8_SRGB_PACK32"), |
| std::make_pair(58, "VK_FORMAT_A2R10G10B10_UNORM_PACK32"), |
| std::make_pair(59, "VK_FORMAT_A2R10G10B10_SNORM_PACK32"), |
| std::make_pair(60, "VK_FORMAT_A2R10G10B10_USCALED_PACK32"), |
| std::make_pair(61, "VK_FORMAT_A2R10G10B10_SSCALED_PACK32"), |
| std::make_pair(62, "VK_FORMAT_A2R10G10B10_UINT_PACK32"), |
| std::make_pair(63, "VK_FORMAT_A2R10G10B10_SINT_PACK32"), |
| std::make_pair(64, "VK_FORMAT_A2B10G10R10_UNORM_PACK32"), |
| std::make_pair(65, "VK_FORMAT_A2B10G10R10_SNORM_PACK32"), |
| std::make_pair(66, "VK_FORMAT_A2B10G10R10_USCALED_PACK32"), |
| std::make_pair(67, "VK_FORMAT_A2B10G10R10_SSCALED_PACK32"), |
| std::make_pair(68, "VK_FORMAT_A2B10G10R10_UINT_PACK32"), |
| std::make_pair(69, "VK_FORMAT_A2B10G10R10_SINT_PACK32"), |
| std::make_pair(70, "VK_FORMAT_R16_UNORM"), |
| std::make_pair(71, "VK_FORMAT_R16_SNORM"), |
| std::make_pair(72, "VK_FORMAT_R16_USCALED"), |
| std::make_pair(73, "VK_FORMAT_R16_SSCALED"), |
| std::make_pair(74, "VK_FORMAT_R16_UINT"), |
| std::make_pair(75, "VK_FORMAT_R16_SINT"), |
| std::make_pair(76, "VK_FORMAT_R16_SFLOAT"), |
| std::make_pair(77, "VK_FORMAT_R16G16_UNORM"), |
| std::make_pair(78, "VK_FORMAT_R16G16_SNORM"), |
| std::make_pair(79, "VK_FORMAT_R16G16_USCALED"), |
| std::make_pair(80, "VK_FORMAT_R16G16_SSCALED"), |
| std::make_pair(81, "VK_FORMAT_R16G16_UINT"), |
| std::make_pair(82, "VK_FORMAT_R16G16_SINT"), |
| std::make_pair(83, "VK_FORMAT_R16G16_SFLOAT"), |
| std::make_pair(84, "VK_FORMAT_R16G16B16_UNORM"), |
| std::make_pair(85, "VK_FORMAT_R16G16B16_SNORM"), |
| std::make_pair(86, "VK_FORMAT_R16G16B16_USCALED"), |
| std::make_pair(87, "VK_FORMAT_R16G16B16_SSCALED"), |
| std::make_pair(88, "VK_FORMAT_R16G16B16_UINT"), |
| std::make_pair(89, "VK_FORMAT_R16G16B16_SINT"), |
| std::make_pair(90, "VK_FORMAT_R16G16B16_SFLOAT"), |
| std::make_pair(91, "VK_FORMAT_R16G16B16A16_UNORM"), |
| std::make_pair(92, "VK_FORMAT_R16G16B16A16_SNORM"), |
| std::make_pair(93, "VK_FORMAT_R16G16B16A16_USCALED"), |
| std::make_pair(94, "VK_FORMAT_R16G16B16A16_SSCALED"), |
| std::make_pair(95, "VK_FORMAT_R16G16B16A16_UINT"), |
| std::make_pair(96, "VK_FORMAT_R16G16B16A16_SINT"), |
| std::make_pair(97, "VK_FORMAT_R16G16B16A16_SFLOAT"), |
| std::make_pair(98, "VK_FORMAT_R32_UINT"), |
| std::make_pair(99, "VK_FORMAT_R32_SINT"), |
| std::make_pair(100, "VK_FORMAT_R32_SFLOAT"), |
| std::make_pair(101, "VK_FORMAT_R32G32_UINT"), |
| std::make_pair(102, "VK_FORMAT_R32G32_SINT"), |
| std::make_pair(103, "VK_FORMAT_R32G32_SFLOAT"), |
| std::make_pair(104, "VK_FORMAT_R32G32B32_UINT"), |
| std::make_pair(105, "VK_FORMAT_R32G32B32_SINT"), |
| std::make_pair(106, "VK_FORMAT_R32G32B32_SFLOAT"), |
| std::make_pair(107, "VK_FORMAT_R32G32B32A32_UINT"), |
| std::make_pair(108, "VK_FORMAT_R32G32B32A32_SINT"), |
| std::make_pair(109, "VK_FORMAT_R32G32B32A32_SFLOAT"), |
| std::make_pair(110, "VK_FORMAT_R64_UINT"), |
| std::make_pair(111, "VK_FORMAT_R64_SINT"), |
| std::make_pair(112, "VK_FORMAT_R64_SFLOAT"), |
| std::make_pair(113, "VK_FORMAT_R64G64_UINT"), |
| std::make_pair(114, "VK_FORMAT_R64G64_SINT"), |
| std::make_pair(115, "VK_FORMAT_R64G64_SFLOAT"), |
| std::make_pair(116, "VK_FORMAT_R64G64B64_UINT"), |
| std::make_pair(117, "VK_FORMAT_R64G64B64_SINT"), |
| std::make_pair(118, "VK_FORMAT_R64G64B64_SFLOAT"), |
| std::make_pair(119, "VK_FORMAT_R64G64B64A64_UINT"), |
| std::make_pair(120, "VK_FORMAT_R64G64B64A64_SINT"), |
| std::make_pair(121, "VK_FORMAT_R64G64B64A64_SFLOAT"), |
| std::make_pair(122, "VK_FORMAT_B10G11R11_UFLOAT_PACK32"), |
| std::make_pair(123, "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32"), |
| std::make_pair(124, "VK_FORMAT_D16_UNORM"), |
| std::make_pair(125, "VK_FORMAT_X8_D24_UNORM_PACK32"), |
| std::make_pair(126, "VK_FORMAT_D32_SFLOAT"), |
| std::make_pair(127, "VK_FORMAT_S8_UINT"), |
| std::make_pair(128, "VK_FORMAT_D16_UNORM_S8_UINT"), |
| std::make_pair(129, "VK_FORMAT_D24_UNORM_S8_UINT"), |
| std::make_pair(130, "VK_FORMAT_D32_SFLOAT_S8_UINT"), |
| std::make_pair(131, "VK_FORMAT_BC1_RGB_UNORM_BLOCK"), |
| std::make_pair(132, "VK_FORMAT_BC1_RGB_SRGB_BLOCK"), |
| std::make_pair(133, "VK_FORMAT_BC1_RGBA_UNORM_BLOCK"), |
| std::make_pair(134, "VK_FORMAT_BC1_RGBA_SRGB_BLOCK"), |
| std::make_pair(135, "VK_FORMAT_BC2_UNORM_BLOCK"), |
| std::make_pair(136, "VK_FORMAT_BC2_SRGB_BLOCK"), |
| std::make_pair(137, "VK_FORMAT_BC3_UNORM_BLOCK"), |
| std::make_pair(138, "VK_FORMAT_BC3_SRGB_BLOCK"), |
| std::make_pair(139, "VK_FORMAT_BC4_UNORM_BLOCK"), |
| std::make_pair(140, "VK_FORMAT_BC4_SNORM_BLOCK"), |
| std::make_pair(141, "VK_FORMAT_BC5_UNORM_BLOCK"), |
| std::make_pair(142, "VK_FORMAT_BC5_SNORM_BLOCK"), |
| std::make_pair(143, "VK_FORMAT_BC6H_UFLOAT_BLOCK"), |
| std::make_pair(144, "VK_FORMAT_BC6H_SFLOAT_BLOCK"), |
| std::make_pair(145, "VK_FORMAT_BC7_UNORM_BLOCK"), |
| std::make_pair(146, "VK_FORMAT_BC7_SRGB_BLOCK"), |
| std::make_pair(147, "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK"), |
| std::make_pair(148, "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK"), |
| std::make_pair(149, "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"), |
| std::make_pair(150, "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"), |
| std::make_pair(151, "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"), |
| std::make_pair(152, "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"), |
| std::make_pair(153, "VK_FORMAT_EAC_R11_UNORM_BLOCK"), |
| std::make_pair(154, "VK_FORMAT_EAC_R11_SNORM_BLOCK"), |
| std::make_pair(155, "VK_FORMAT_EAC_R11G11_UNORM_BLOCK"), |
| std::make_pair(156, "VK_FORMAT_EAC_R11G11_SNORM_BLOCK"), |
| std::make_pair(157, "VK_FORMAT_ASTC_4x4_UNORM_BLOCK"), |
| std::make_pair(158, "VK_FORMAT_ASTC_4x4_SRGB_BLOCK"), |
| std::make_pair(159, "VK_FORMAT_ASTC_5x4_UNORM_BLOCK"), |
| std::make_pair(160, "VK_FORMAT_ASTC_5x4_SRGB_BLOCK"), |
| std::make_pair(161, "VK_FORMAT_ASTC_5x5_UNORM_BLOCK"), |
| std::make_pair(162, "VK_FORMAT_ASTC_5x5_SRGB_BLOCK"), |
| std::make_pair(163, "VK_FORMAT_ASTC_6x5_UNORM_BLOCK"), |
| std::make_pair(164, "VK_FORMAT_ASTC_6x5_SRGB_BLOCK"), |
| std::make_pair(165, "VK_FORMAT_ASTC_6x6_UNORM_BLOCK"), |
| std::make_pair(166, "VK_FORMAT_ASTC_6x6_SRGB_BLOCK"), |
| std::make_pair(167, "VK_FORMAT_ASTC_8x5_UNORM_BLOCK"), |
| std::make_pair(168, "VK_FORMAT_ASTC_8x5_SRGB_BLOCK"), |
| std::make_pair(169, "VK_FORMAT_ASTC_8x6_UNORM_BLOCK"), |
| std::make_pair(170, "VK_FORMAT_ASTC_8x6_SRGB_BLOCK"), |
| std::make_pair(171, "VK_FORMAT_ASTC_8x8_UNORM_BLOCK"), |
| std::make_pair(172, "VK_FORMAT_ASTC_8x8_SRGB_BLOCK"), |
| std::make_pair(173, "VK_FORMAT_ASTC_10x5_UNORM_BLOCK"), |
| std::make_pair(174, "VK_FORMAT_ASTC_10x5_SRGB_BLOCK"), |
| std::make_pair(175, "VK_FORMAT_ASTC_10x6_UNORM_BLOCK"), |
| std::make_pair(176, "VK_FORMAT_ASTC_10x6_SRGB_BLOCK"), |
| std::make_pair(177, "VK_FORMAT_ASTC_10x8_UNORM_BLOCK"), |
| std::make_pair(178, "VK_FORMAT_ASTC_10x8_SRGB_BLOCK"), |
| std::make_pair(179, "VK_FORMAT_ASTC_10x10_UNORM_BLOCK"), |
| std::make_pair(180, "VK_FORMAT_ASTC_10x10_SRGB_BLOCK"), |
| std::make_pair(181, "VK_FORMAT_ASTC_12x10_UNORM_BLOCK"), |
| std::make_pair(182, "VK_FORMAT_ASTC_12x10_SRGB_BLOCK"), |
| std::make_pair(183, "VK_FORMAT_ASTC_12x12_UNORM_BLOCK"), |
| std::make_pair(184, "VK_FORMAT_ASTC_12x12_SRGB_BLOCK"), |
| std::make_pair(1000156000, "VK_FORMAT_G8B8G8R8_422_UNORM"), |
| std::make_pair(1000156001, "VK_FORMAT_B8G8R8G8_422_UNORM"), |
| std::make_pair(1000156002, "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM"), |
| std::make_pair(1000156003, "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM"), |
| std::make_pair(1000156004, "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM"), |
| std::make_pair(1000156005, "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM"), |
| std::make_pair(1000156006, "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM"), |
| std::make_pair(1000156007, "VK_FORMAT_R10X6_UNORM_PACK16"), |
| std::make_pair(1000156008, "VK_FORMAT_R10X6G10X6_UNORM_2PACK16"), |
| std::make_pair(1000156009, "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"), |
| std::make_pair(1000156010, "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"), |
| std::make_pair(1000156011, "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"), |
| std::make_pair(1000156012, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"), |
| std::make_pair(1000156013, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"), |
| std::make_pair(1000156014, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"), |
| std::make_pair(1000156015, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"), |
| std::make_pair(1000156016, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"), |
| std::make_pair(1000156017, "VK_FORMAT_R12X4_UNORM_PACK16"), |
| std::make_pair(1000156018, "VK_FORMAT_R12X4G12X4_UNORM_2PACK16"), |
| std::make_pair(1000156019, "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"), |
| std::make_pair(1000156020, "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"), |
| std::make_pair(1000156021, "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"), |
| std::make_pair(1000156022, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"), |
| std::make_pair(1000156023, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"), |
| std::make_pair(1000156024, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"), |
| std::make_pair(1000156025, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"), |
| std::make_pair(1000156026, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"), |
| std::make_pair(1000156027, "VK_FORMAT_G16B16G16R16_422_UNORM"), |
| std::make_pair(1000156028, "VK_FORMAT_B16G16R16G16_422_UNORM"), |
| std::make_pair(1000156029, "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM"), |
| std::make_pair(1000156030, "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM"), |
| std::make_pair(1000156031, "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM"), |
| std::make_pair(1000156032, "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM"), |
| std::make_pair(1000156033, "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM"), |
| std::make_pair(1000054000, "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"), |
| std::make_pair(1000054001, "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"), |
| std::make_pair(1000054002, "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"), |
| std::make_pair(1000054003, "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"), |
| std::make_pair(1000054004, "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"), |
| std::make_pair(1000054005, "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"), |
| std::make_pair(1000054006, "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"), |
| std::make_pair(1000054007, "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"), |
| std::make_pair(1000066000, "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066001, "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066002, "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066003, "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066004, "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066005, "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066006, "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066007, "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066008, "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066009, "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066010, "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066011, "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066012, "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000066013, "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288000, "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288001, "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288002, "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288003, "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288004, "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288005, "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288006, "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288007, "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288008, "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288009, "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288010, "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288011, "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288012, "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288013, "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288014, "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288015, "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288016, "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288017, "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288018, "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288019, "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288020, "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288021, "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288022, "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288023, "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288024, "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288025, "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288026, "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000288027, "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT"), |
| std::make_pair(1000288028, "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT"), |
| std::make_pair(1000288029, "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT"), |
| std::make_pair(1000330000, "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT"), |
| std::make_pair(1000330001, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT"), |
| std::make_pair(1000330002, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT"), |
| std::make_pair(1000330003, "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT"), |
| std::make_pair(1000340000, "VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT"), |
| std::make_pair(1000340001, "VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT"), |
| }; |
| static void print_VkFormat(VkFormat obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkFormat_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkFormat_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkFormat(const VkFormat * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkFormat_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkFormat_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkFormatFeatureFlagBits_map = { |
| std::make_pair(1ULL << 0, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"), |
| std::make_pair(1ULL << 1, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"), |
| std::make_pair(1ULL << 2, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"), |
| std::make_pair(1ULL << 3, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"), |
| std::make_pair(1ULL << 4, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"), |
| std::make_pair(1ULL << 5, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"), |
| std::make_pair(1ULL << 6, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"), |
| std::make_pair(1ULL << 7, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"), |
| std::make_pair(1ULL << 8, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"), |
| std::make_pair(1ULL << 9, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"), |
| std::make_pair(1ULL << 10, "VK_FORMAT_FEATURE_BLIT_SRC_BIT"), |
| std::make_pair(1ULL << 11, "VK_FORMAT_FEATURE_BLIT_DST_BIT"), |
| std::make_pair(1ULL << 12, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"), |
| std::make_pair(1ULL << 14, "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"), |
| std::make_pair(1ULL << 15, "VK_FORMAT_FEATURE_TRANSFER_DST_BIT"), |
| std::make_pair(1ULL << 17, "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"), |
| std::make_pair(1ULL << 18, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"), |
| std::make_pair(1ULL << 19, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"), |
| std::make_pair(1ULL << 20, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"), |
| std::make_pair(1ULL << 21, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"), |
| std::make_pair(1ULL << 22, "VK_FORMAT_FEATURE_DISJOINT_BIT"), |
| std::make_pair(1ULL << 23, "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"), |
| std::make_pair(1ULL << 16, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"), |
| std::make_pair(1ULL << 13, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG"), |
| std::make_pair(1ULL << 25, "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"), |
| std::make_pair(1ULL << 26, "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"), |
| std::make_pair(1ULL << 29, "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"), |
| std::make_pair(1ULL << 24, "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"), |
| std::make_pair(1ULL << 30, "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"), |
| std::make_pair(1ULL << 27, "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"), |
| std::make_pair(1ULL << 28, "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"), |
| }; |
| static void print_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkFormatFeatureFlagBits_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkFormatFeatureFlagBits_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkFormatFeatureFlagBits_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkFormatFeatureFlagBits_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkImageCreateFlagBits_map = { |
| std::make_pair(1ULL << 0, "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"), |
| std::make_pair(1ULL << 1, "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"), |
| std::make_pair(1ULL << 2, "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"), |
| std::make_pair(1ULL << 3, "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"), |
| std::make_pair(1ULL << 4, "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"), |
| std::make_pair(1ULL << 10, "VK_IMAGE_CREATE_ALIAS_BIT"), |
| std::make_pair(1ULL << 6, "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"), |
| std::make_pair(1ULL << 5, "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"), |
| std::make_pair(1ULL << 7, "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"), |
| std::make_pair(1ULL << 8, "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"), |
| std::make_pair(1ULL << 11, "VK_IMAGE_CREATE_PROTECTED_BIT"), |
| std::make_pair(1ULL << 9, "VK_IMAGE_CREATE_DISJOINT_BIT"), |
| std::make_pair(1ULL << 13, "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"), |
| std::make_pair(1ULL << 12, "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"), |
| std::make_pair(1ULL << 14, "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT"), |
| std::make_pair(1ULL << 16, "VK_IMAGE_CREATE_RESERVED_16_BIT_AMD"), |
| std::make_pair(1ULL << 17, "VK_IMAGE_CREATE_RESERVED_394_BIT_EXT"), |
| std::make_pair(1ULL << 15, "VK_IMAGE_CREATE_RESERVED_426_BIT_QCOM"), |
| }; |
| static void print_VkImageCreateFlagBits(VkImageCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkImageCreateFlagBits_map[obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkImageCreateFlagBits_map[obj] << "\"" << std::endl; |
| } |
| static void print_VkImageCreateFlagBits(const VkImageCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { |
| PRINT_SPACE |
| if (str != "") _OUT << "\"" << str << "\"" << " : "; |
| if (commaNeeded) |
| _OUT << "\"" << VkImageCreateFlagBits_map[*obj] << "\"," << std::endl; |
| else |
| _OUT << "\"" << VkImageCreateFlagBits_map[*obj] << "\"" << std::endl; |
| } |
| |
| static std::map<deUint64, std::string> VkSampleCountFlagBits_map = { |
| std::make_pair(1ULL << 0, "VK_SAMPLE_COUNT_1_BIT"), |
| std::make_pair(1ULL << 1, "VK_SAMPLE_COUNT_2_BIT"), |
| std::make_pair(1ULL << 2, "VK_SAMPLE_COUNT_4_BIT"), |
| std::make_pair(1ULL << 3, "VK_SAMPLE_COUNT_8_BIT"), |
| std::make_pair(1ULL << 4 |