From cb55e77f53de6511e736ff339254533c53f53c3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= Date: Tue, 24 Oct 2017 16:15:43 +0200 Subject: [PATCH] Adjustments for Vulkan 1.0.64 (#140) --- Vulkan-Docs | 2 +- VulkanHppGenerator.cpp | 579 +++++++++++++++++++++++++++++------------ tinyxml2 | 2 +- vulkan/vulkan.hpp | 413 +++++++++++++++++++++-------- 4 files changed, 729 insertions(+), 267 deletions(-) diff --git a/Vulkan-Docs b/Vulkan-Docs index d2d907e..5436521 160000 --- a/Vulkan-Docs +++ b/Vulkan-Docs @@ -1 +1 @@ -Subproject commit d2d907e4f3730bc4290b518faf0604492b302693 +Subproject commit 5436521608c40f324b397693f5bb758d666e3f55 diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index b205795..cf6ed3c 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -790,10 +790,11 @@ struct DependencyData std::set forwardDependencies; }; -struct NameValue +struct EnumValueData { std::string name; std::string value; + std::string alias; }; struct EnumData @@ -803,25 +804,28 @@ struct EnumData , bitmask(b) {} - void addEnumMember(std::string const& name, std::string const& tag); + void addEnumValue(std::string const& name, std::string const& tag); - std::string name; - std::string prefix; - std::string postfix; - std::vector members; - std::string protect; - bool bitmask; + std::string name; + std::string prefix; + std::string postfix; + std::vector values; + std::string protect; + bool bitmask; + std::string alias; }; struct FlagData { std::string protect; + std::string alias; }; struct HandleData { std::vector commands; std::string protect; + std::string alias; }; struct ScalarData @@ -843,11 +847,12 @@ struct StructData : returnedOnly(false) {} - bool returnedOnly; - bool isUnion; - std::vector members; - std::string protect; - std::vector structExtends; + bool returnedOnly; + bool isUnion; + std::vector members; + std::string protect; + std::vector structExtends; + std::string alias; }; struct DeleterData @@ -867,9 +872,11 @@ struct ExtensionData struct VkData { std::map commands; + std::map constants; + std::set defines; std::list dependencies; + std::map deleters; // map from child types to corresponding deleter data std::map> deleterTypes; // map from parent type to set of child types - std::map deleterData; // map from child types to corresponding deleter data std::map enums; std::map flags; std::map handles; @@ -886,6 +893,7 @@ struct VkData #endif }; +void aliasEnum(VkData & vkData, std::map::iterator enumsIt, std::string const& newName, std::string const& protect); void createDefaults( VkData const& vkData, std::map & defaultValues ); void determineEnhancedReturnType(CommandData & commandData); void determineReducedName(CommandData & commandData); @@ -910,14 +918,19 @@ void readCommandsCommand(tinyxml2::XMLElement * element, VkData & vkData); std::vector readCommandSuccessCodes(tinyxml2::XMLElement* element, std::set const& tags); void readComment(tinyxml2::XMLElement * element, std::string & header); void readEnums( tinyxml2::XMLElement * element, VkData & vkData ); +void readEnumsConstant(tinyxml2::XMLElement * element, std::map & constants); void readEnumsEnum( tinyxml2::XMLElement * element, EnumData & enumData ); void readDisabledExtensionRequire(tinyxml2::XMLElement * element, VkData & vkData); +void readExtensionAlias(tinyxml2::XMLElement * element, VkData & vkData, std::string const& protect, std::string const& tag); void readExtensionCommand(tinyxml2::XMLElement * element, std::map & commands, std::string const& protect); void readExtensionEnum(tinyxml2::XMLElement * element, std::map & enums, std::string const& tag); void readExtensionRequire(tinyxml2::XMLElement * element, VkData & vkData, std::string const& protect, std::string const& tag); void readExtensions( tinyxml2::XMLElement * element, VkData & vkData ); void readExtensionsExtension(tinyxml2::XMLElement * element, VkData & vkData); void readExtensionType(tinyxml2::XMLElement * element, VkData & vkData, std::string const& protect); +void readFeature(tinyxml2::XMLElement * element, std::map & enums); +void readFeatureRequire(tinyxml2::XMLElement * element, std::map & enums); +void readFeatureRequireEnum(tinyxml2::XMLElement * element, std::map & enums); tinyxml2::XMLNode* readType(tinyxml2::XMLNode* element, std::string & type, std::string & pureType); void readTypeBasetype( tinyxml2::XMLElement * element, std::list & dependencies ); void readTypeBitmask( tinyxml2::XMLElement * element, VkData & vkData); @@ -928,6 +941,7 @@ void readTypeStruct( tinyxml2::XMLElement * element, VkData & vkData, bool isUni void readTypeStructMember( tinyxml2::XMLElement * element, VkData & vkData, StructData & structData ); void readTags(tinyxml2::XMLElement * element, std::set & tags); void readTypes(tinyxml2::XMLElement * element, VkData & vkData); +void readTypesType(tinyxml2::XMLElement * element, VkData & vkData); std::string reduceName(std::string const& name, bool singular = false); void registerDeleter(VkData & vkData, CommandData const& commandData); std::string startLowerCase(std::string const& input); @@ -938,6 +952,7 @@ std::string stripPluralS(std::string const& name); std::string toCamelCase(std::string const& value); std::vector tokenize(std::string tokenString, char separator); std::string toUpperCase(std::string const& name); +std::string trim(std::string const& input); std::string trimEnd(std::string const& input); void writeCall(std::ostream & os, CommandData const& commandData, std::set const& vkTypes, bool firstCall, bool singular); std::string generateCall(CommandData const& commandData, std::set const& vkTypes, bool firstCall, bool singular); @@ -946,8 +961,8 @@ void writeCallParameter(std::ostream & os, ParamData const& paramData, std::set< void writeCallPlainTypeParameter(std::ostream & os, ParamData const& paramData); void writeCallVectorParameter(std::ostream & os, CommandData const& commandData, std::set const& vkTypes, bool firstCall, bool singular, std::map::const_iterator it); void writeCallVulkanTypeParameter(std::ostream & os, ParamData const& paramData); -void writeDeleterClasses(std::ostream & os, std::pair> const& deleterTypes, std::map const& deleterData); -void writeDeleterForwardDeclarations(std::ostream &os, std::pair> const& deleterTypes, std::map const& deleterData); +void writeDeleterClasses(std::ostream & os, std::pair> const& deleterTypes, std::map const& deleters); +void writeDeleterForwardDeclarations(std::ostream &os, std::pair> const& deleterTypes, std::map const& deleters); void writeEnumsToString(std::ostream & os, EnumData const& enumData); void writeFlagsToString(std::ostream & os, std::string const& flagsName, EnumData const &enumData); void writeFunction(std::ostream & os, std::string const& indentation, VkData const& vkData, CommandData const& commandData, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain); @@ -989,24 +1004,47 @@ void writeTypes(std::ostream & os, VkData const& vkData, std::mapvalue == evd.value); + } +} + +void aliasEnum(VkData & vkData, std::map::iterator enumsIt, std::string const& newName, std::string const& protect) +{ + assert(vkData.enums.find(newName) == vkData.enums.end()); + assert(enumsIt->second.protect == protect); + assert(enumsIt->second.alias.empty()); + enumsIt->second.alias = newName; } void createDefaults( VkData const& vkData, std::map & defaultValues ) @@ -1022,9 +1060,9 @@ void createDefaults( VkData const& vkData, std::map & d { assert(vkData.enums.find(dependency.name) != vkData.enums.end()); EnumData const & enumData = vkData.enums.find(dependency.name)->second; - if (!enumData.members.empty()) + if (!enumData.values.empty()) { - defaultValues[dependency.name] = dependency.name + "::" + vkData.enums.find(dependency.name)->second.members.front().name; + defaultValues[dependency.name] = dependency.name + "::" + vkData.enums.find(dependency.name)->second.values.front().name; } else { @@ -1304,7 +1342,7 @@ std::string readArraySize(tinyxml2::XMLNode * node, std::string& name) node = node->NextSibling(); if (node && node->ToText()) { - std::string value = node->Value(); + std::string value = trimEnd(node->Value()); if (value == "[") { // if this node has '[' as its value, the next node holds the array size, and the node after that needs to hold ']', and there should be no more siblings @@ -1312,7 +1350,7 @@ std::string readArraySize(tinyxml2::XMLNode * node, std::string& name) assert(node && node->ToElement() && (strcmp(node->Value(), "enum") == 0)); arraySize = node->ToElement()->GetText(); node = node->NextSibling(); - assert(node && node->ToText() && (strcmp(node->Value(), "]") == 0)); + assert(node && node->ToText() && (trimEnd(node->Value()) == "]")); } else { @@ -1330,9 +1368,15 @@ bool readCommandParam( tinyxml2::XMLElement * element, std::set & d { ParamData param; + bool isTwoStep = false; if (element->Attribute("len")) { param.len = element->Attribute("len"); + auto pit = std::find_if(params.begin(), params.end(), [¶m](ParamData const& pd) { return param.len == pd.name; }); + if (pit != params.end()) + { + isTwoStep = (pit->type.find('*') != std::string::npos); + } } // get the type of the parameter, and put it into the list of dependencies @@ -1348,8 +1392,8 @@ bool readCommandParam( tinyxml2::XMLElement * element, std::set & d params.push_back(param); - // an optional parameter with "false,true" value is supposed to be part of a two-step algorithm: first get the size, than use it - return element->Attribute("optional") && (strcmp(element->Attribute("optional"), "false,true") == 0); + assert(!isTwoStep || (param.type.substr(0, 6) != "const ")); + return isTwoStep; } void readCommandParams(tinyxml2::XMLElement* element, std::set & dependencies, CommandData & commandData) @@ -1377,7 +1421,7 @@ tinyxml2::XMLNode* readCommandParamType(tinyxml2::XMLNode* node, ParamData& para if (node->ToText()) { // start type with "const" or "struct", if needed - std::string value = trimEnd(node->Value()); + std::string value = trim(node->Value()); assert((value == "const") || (value == "struct")); param.type = value + " "; node = node->NextSibling(); @@ -1502,7 +1546,14 @@ void readEnums( tinyxml2::XMLElement * element, VkData & vkData ) } std::string name = strip(element->Attribute("name"), "Vk"); - if ( name != "API Constants" ) // skip the "API Constants" + if (name == "API Constants") + { + for (tinyxml2::XMLElement * child = element->FirstChildElement(); child; child = child->NextSiblingElement()) + { + readEnumsConstant(child, vkData.constants); + } + } + else { // add an empty DependencyData on this name into the dependencies list vkData.dependencies.push_back( DependencyData( DependencyData::Category::ENUM, name ) ); @@ -1568,6 +1619,14 @@ void readEnums( tinyxml2::XMLElement * element, VkData & vkData ) } } +void readEnumsConstant(tinyxml2::XMLElement * element, std::map & constants) +{ + assert((strcmp(element->Value(), "enum") == 0) && element->Attribute("value") && element->Attribute("name")); + std::string name = element->Attribute("name"); + assert(constants.find(name) == constants.end()); + constants[name] = element->Attribute("value"); +} + void readEnumsEnum( tinyxml2::XMLElement * element, EnumData & enumData ) { // read the names of the enum values @@ -1576,7 +1635,7 @@ void readEnumsEnum( tinyxml2::XMLElement * element, EnumData & enumData ) { if ( child->Attribute( "name" ) ) { - enumData.addEnumMember(child->Attribute("name"), ""); + enumData.addEnumValue(child->Attribute("name"), ""); } child = child->NextSiblingElement(); } @@ -1636,6 +1695,109 @@ void readDisabledExtensionRequire(tinyxml2::XMLElement * element, VkData & vkDat } } +void readExtensionAlias(tinyxml2::XMLElement * element, VkData & vkData, std::string const& protect, std::string const& tag) +{ + assert(element->Attribute("name") && element->Attribute("value")); + std::string name = element->Attribute("name"); + std::string value = element->Attribute("value"); + + auto commandsIt = vkData.commands.find(startLowerCase(strip(value, "vk"))); + if (commandsIt != vkData.commands.end()) + { + // the alias is on a command -> add a command with that name + CommandData commandData = commandsIt->second; + commandData.fullName = startLowerCase(strip(name, "vk")); + assert(vkData.commands.find(commandData.fullName) == vkData.commands.end()); + + determineReducedName(commandData); + vkData.commands.insert(std::make_pair(commandData.fullName, commandData)); + } + else + { + auto constantsIt = vkData.constants.find(value); + if (constantsIt != vkData.constants.end()) + { + // alias on a constant -> just add it to the set of constants... we're doing nothing with them + auto it = vkData.constants.find(name); + assert((vkData.constants.find(name) == vkData.constants.end()) || (vkData.constants.find(name)->second == constantsIt->second)); + vkData.constants[name] = constantsIt->second; + } + else + { + std::string strippedValue = strip(value, "Vk"); + std::string strippedName = strip(name, "Vk"); + + auto enumsIt = vkData.enums.find(strippedValue); + if (enumsIt != vkData.enums.end()) + { + // the alias is on an enum -> set the alias, which will map to a using directive + aliasEnum(vkData, enumsIt, strippedName, protect); + } + else + { + auto flagsIt = vkData.flags.find(strippedValue); + if (flagsIt != vkData.flags.end()) + { + // the alias is on a flags -> set the alias, which will map to a using directive + assert(vkData.flags.find(strippedName) == vkData.flags.end()); + assert(flagsIt->second.alias.empty()); + flagsIt->second.alias = strippedName; + + // adjust the generated enum name as well, if it's empty (and therefore auto-generated) + std::string enumName = generateEnumNameForFlags(strippedValue); + std::map::iterator enumsIt = vkData.enums.find(enumName); + assert(enumsIt != vkData.enums.end()); + if (enumsIt->second.values.empty()) + { + aliasEnum(vkData, enumsIt, generateEnumNameForFlags(flagsIt->second.alias), protect); + } + } + else + { + auto handlesIt = vkData.handles.find(strippedValue); + if (handlesIt != vkData.handles.end()) + { + assert(vkData.handles.find(strippedName) == vkData.handles.end()); + assert(handlesIt->second.protect == protect); + assert(handlesIt->second.alias.empty()); + handlesIt->second.alias = strippedName; + } + else + { + auto structsIt = vkData.structs.find(strippedValue); + if (structsIt != vkData.structs.end()) + { + // the alias is on a structure -> set the alias, which will map to a using directive + assert(vkData.structs.find(strippedName) == vkData.structs.end()); + assert(structsIt->second.protect == protect); + assert(structsIt->second.alias.empty() || (structsIt->second.alias == strippedName)); + structsIt->second.alias = strippedName; + } + else + { + // final catch: it has to be an enum value + bool found = false; + for (auto & e : vkData.enums) + { + auto valueIt = std::find_if(e.second.values.begin(), e.second.values.end(), [&value](EnumValueData const& evd) { return evd.value == value; }); + if (valueIt != e.second.values.end()) + { + assert(std::find_if(e.second.values.begin(), e.second.values.end(), [&name](EnumValueData const& evd) {return evd.value == name; }) == e.second.values.end()); + assert(valueIt->alias.empty()); + valueIt->alias = createEnumValueName(name, e.second.prefix, e.second.postfix, e.second.bitmask, tag); + found = true; + break; + } + } + assert(found); + } + } + } + } + } + } +} + void readExtensionCommand(tinyxml2::XMLElement * element, std::map & commands, std::string const& protect) { // just add the protect string to the CommandData @@ -1655,11 +1817,12 @@ void readExtensionEnum(tinyxml2::XMLElement * element, std::mapAttribute("extends")) { assert(element->Attribute("name")); - assert(enums.find(strip(element->Attribute("extends"), "Vk")) != enums.end()); + std::string extends = strip(element->Attribute("extends"), "Vk"); + assert(enums.find(extends) != enums.end()); assert(!!element->Attribute("bitpos") + !!element->Attribute("offset") + !!element->Attribute("value") == 1); - auto enumIt = enums.find(strip(element->Attribute("extends"), "Vk")); + auto enumIt = enums.find(extends); assert(enumIt != enums.end()); - enumIt->second.addEnumMember(element->Attribute("name"), tag); + enumIt->second.addEnumValue(element->Attribute("name"), tag); } } @@ -1669,7 +1832,11 @@ void readExtensionRequire(tinyxml2::XMLElement * element, VkData & vkData, std:: { std::string value = child->Value(); - if ( value == "command" ) + if (value == "alias") + { + readExtensionAlias(child, vkData, protect, tag); + } + else if ( value == "command" ) { readExtensionCommand(child, vkData.commands, protect); } @@ -1721,6 +1888,11 @@ void readExtensionsExtension(tinyxml2::XMLElement * element, VkData & vkData) { protect = element->Attribute("protect"); } + else if (element->Attribute("platform")) + { + assert(element->Attribute("author")); + protect = "VK_USE_PLATFORM_" + toUpperCase(element->Attribute("platform")) + "_" + element->Attribute("author"); + } #if !defined(NDEBUG) assert(vkData.extensions.find(name) == vkData.extensions.end()); @@ -1763,7 +1935,7 @@ void readExtensionType(tinyxml2::XMLElement * element, VkData & vkData, std::str std::string enumName = generateEnumNameForFlags(name); std::map::iterator eit = vkData.enums.find(enumName); assert(eit != vkData.enums.end()); - if (eit->second.members.empty()) + if (eit->second.values.empty()) { eit->second.protect = protect; } @@ -1785,8 +1957,14 @@ void readExtensionType(tinyxml2::XMLElement * element, VkData & vkData, std::str else { std::map::iterator stit = vkData.structs.find(name); - assert(stit != vkData.structs.end() && stit->second.protect.empty()); - stit->second.protect = protect; + if (stit != vkData.structs.end()) + { + stit->second.protect = protect; + } + else + { + assert(vkData.defines.find(name) != vkData.defines.end()); + } } } } @@ -1794,12 +1972,54 @@ void readExtensionType(tinyxml2::XMLElement * element, VkData & vkData, std::str } } +void readFeature(tinyxml2::XMLElement * element, std::map & enums) +{ + assert(element->Attribute("api") && (strcmp(element->Attribute("api"), "vulkan") == 0)); + + for (tinyxml2::XMLElement * child = element->FirstChildElement(); child; child = child->NextSiblingElement()) + { + assert(child->Value()); + std::string value = child->Value(); + assert(value == "require"); + readFeatureRequire(child, enums); + } +} + +void readFeatureRequire(tinyxml2::XMLElement * element, std::map & enums) +{ + for (tinyxml2::XMLElement * child = element->FirstChildElement(); child; child = child->NextSiblingElement()) + { + assert(child->Value()); + std::string value = child->Value(); + if (value == "enum") + { + readFeatureRequireEnum(child, enums); + } + else + { + assert((value == "command") || (value == "type")); + } + } +} + +void readFeatureRequireEnum(tinyxml2::XMLElement * element, std::map & enums) +{ + if (element->Attribute("extends")) + { + assert((strncmp(element->Attribute("extends"), "Vk", 2) == 0) && element->Attribute("name")); + std::string extends = strip(element->Attribute("extends"), "Vk"); + auto enumIt = enums.find(extends); + assert(enumIt != enums.end()); + enumIt->second.addEnumValue(element->Attribute("name"), ""); + } +} + tinyxml2::XMLNode* readType(tinyxml2::XMLNode* element, std::string & type, std::string & pureType) { assert(element); if (element->ToText()) { - std::string value = trimEnd(element->Value()); + std::string value = trim(element->Value()); assert((value == "const") || (value == "struct")); type = value + " "; element = element->NextSibling(); @@ -1897,6 +2117,12 @@ void readTypeDefine( tinyxml2::XMLElement * element, VkData & vkData ) size_t end = text.find_first_of("\r\n", start + 1); vkData.typesafeCheck = text.substr(start, end - start); } + else if (element->GetText() && (trim(element->GetText()) == "struct")) + { + assert(child && (strcmp(child->Value(), "name") == 0) && child->GetText()); + vkData.defines.insert(child->GetText()); + vkData.dependencies.push_back(DependencyData(DependencyData::Category::REQUIRED, child->GetText())); + } // ignore all the other defines } @@ -1978,7 +2204,6 @@ void readTypeStruct( tinyxml2::XMLElement * element, VkData & vkData, bool isUni void readTypeStructMember(tinyxml2::XMLElement * element, VkData & vkData, StructData & structData) { - structData.members.push_back(MemberData()); MemberData & member = structData.members.back(); @@ -2008,51 +2233,59 @@ void readTypes(tinyxml2::XMLElement * element, VkData & vkData) { assert(child->Value()); std::string value = child->Value(); - assert((value == "comment") || (value == "type")); if (value == "type") { - if (child->Attribute("category")) - { - std::string category = child->Attribute("category"); - if (category == "basetype") - { - readTypeBasetype(child, vkData.dependencies); - } - else if (category == "bitmask") - { - readTypeBitmask(child, vkData); - } - else if (category == "define") - { - readTypeDefine(child, vkData); - } - else if (category == "funcpointer") - { - readTypeFuncpointer(child, vkData.dependencies); - } - else if (category == "handle") - { - readTypeHandle(child, vkData); - } - else if (category == "struct") - { - readTypeStruct(child, vkData, false); - } - else if (category == "union") - { - readTypeStruct(child, vkData, true); - } - else - { - assert((category == "enum") || (category == "include")); - } - } - else - { - assert(child->Attribute("name")); - vkData.dependencies.push_back(DependencyData(DependencyData::Category::REQUIRED, child->Attribute("name"))); - } + readTypesType(child, vkData); } + else + { + assert(value == "comment"); + } + } +} + +void readTypesType(tinyxml2::XMLElement * element, VkData & vkData) +{ + if (element->Attribute("category")) + { + std::string category = element->Attribute("category"); + if (category == "basetype") + { + readTypeBasetype(element, vkData.dependencies); + } + else if (category == "bitmask") + { + readTypeBitmask(element, vkData); + } + else if (category == "define") + { + readTypeDefine(element, vkData); + } + else if (category == "funcpointer") + { + readTypeFuncpointer(element, vkData.dependencies); + } + else if (category == "handle") + { + readTypeHandle(element, vkData); + } + else if (category == "struct") + { + readTypeStruct(element, vkData, false); + } + else if (category == "union") + { + readTypeStruct(element, vkData, true); + } + else + { + assert((category == "enum") || (category == "include")); + } + } + else + { + assert(element->Attribute("name")); + vkData.dependencies.push_back(DependencyData(DependencyData::Category::REQUIRED, element->Attribute("name"))); } } @@ -2095,8 +2328,8 @@ void registerDeleter(VkData & vkData, CommandData const& commandData) case 4: key = commandData.params[0].pureType; valueIndex = 3; - assert(vkData.deleterData.find(commandData.params[valueIndex].pureType) == vkData.deleterData.end()); - vkData.deleterData[commandData.params[valueIndex].pureType].pool = commandData.params[1].pureType; + assert(vkData.deleters.find(commandData.params[valueIndex].pureType) == vkData.deleters.end()); + vkData.deleters[commandData.params[valueIndex].pureType].pool = commandData.params[1].pureType; break; default: assert(false); @@ -2107,7 +2340,7 @@ void registerDeleter(VkData & vkData, CommandData const& commandData) } assert(vkData.deleterTypes[key].find(commandData.params[valueIndex].pureType) == vkData.deleterTypes[key].end()); vkData.deleterTypes[key].insert(commandData.params[valueIndex].pureType); - vkData.deleterData[commandData.params[valueIndex].pureType].call = commandData.reducedName; + vkData.deleters[commandData.params[valueIndex].pureType].call = commandData.reducedName; } } @@ -2175,14 +2408,24 @@ std::string startUpperCase(std::string const& input) return static_cast(toupper(input[0])) + input.substr(1); } +bool beginsWith(std::string const& text, std::string const& prefix) +{ + return !prefix.empty() && text.substr(0, prefix.length()) == prefix; +} + +bool endsWith(std::string const& text, std::string const& postfix) +{ + return !postfix.empty() && (postfix.length() < text.length()) && (text.substr(text.length() - postfix.length()) == postfix); +} + std::string strip(std::string const& value, std::string const& prefix, std::string const& postfix) { std::string strippedValue = value; - if (strippedValue.substr(0, prefix.length()) == prefix) + if (beginsWith(strippedValue, prefix)) { strippedValue.erase(0, prefix.length()); } - if (!postfix.empty() && (strippedValue.substr(strippedValue.length() - postfix.length()) == postfix)) + if (endsWith(strippedValue, postfix)) { strippedValue.erase(strippedValue.length() - postfix.length()); } @@ -2236,7 +2479,6 @@ std::vector tokenize(std::string tokenString, char separator) std::string toUpperCase(std::string const& name) { - assert(isupper(name.front())); std::string convertedName; for (size_t i = 0; i we need a local variable to hold that value @@ -2738,11 +2984,7 @@ std::string writeFunctionBodyEnhancedLocalReturnVariable(std::ostream & os, std: } } assert(!size.empty()); - os << "( " << size << (returnsVector ? ", {}, {alloc} )" : " )"); - } - else if ( returnsVector ) - { - os << "( {alloc} )"; + os << "( " << size << " )"; } } os << ";" << std::endl; @@ -2890,15 +3132,15 @@ void writeFunctionBodyUnique(std::ostream & os, std::string const& indentation, std::string type = commandData.params[commandData.returnParam].pureType; std::string typeValue = startLowerCase(type); os << indentation << " " << type << "Deleter deleter( "; - if (vkData.deleterData.find(commandData.className) != vkData.deleterData.end()) + if (vkData.deleters.find(commandData.className) != vkData.deleters.end()) { // if the Deleter is specific to the command's class, add '*this' to the deleter os << "*this, "; } // get the DeleterData corresponding to the returned type - std::map::const_iterator ddit = vkData.deleterData.find(type); - assert(ddit != vkData.deleterData.end()); + std::map::const_iterator ddit = vkData.deleters.find(type); + assert(ddit != vkData.deleters.end()); if (ddit->second.pool.empty()) { // if this type isn't pooled, use the allocator (provided as a function argument) @@ -2946,14 +3188,7 @@ void writeFunctionBodyUnique(std::ostream & os, std::string const& indentation, os << argumentName; } } - - if (returnsVector) - { - os << ", alloc"; - } - os << " )"; - if (returnsVector) { std::string const stringTemplate = R"(; @@ -2998,8 +3233,6 @@ void writeFunctionHeaderArguments(std::ostream & os, VkData const& vkData, Comma void writeFunctionHeaderArgumentsEnhanced(std::ostream & os, VkData const& vkData, CommandData const& commandData, bool singular, bool withDefaults) { - bool returnsVector = !singular && (commandData.vectorParams.find(commandData.returnParam) != commandData.vectorParams.end()); - // check if there's at least one argument left to put in here if (commandData.skippedParams.size() + (commandData.className.empty() ? 0 : 1) < commandData.params.size()) { @@ -3051,7 +3284,7 @@ void writeFunctionHeaderArgumentsEnhanced(std::ostream & os, VkData const& vkDat assert((depIt != vkData.dependencies.end()) && (depIt->dependencies.size() == 1)); std::map::const_iterator enumIt = vkData.enums.find(*depIt->dependencies.begin()); assert(enumIt != vkData.enums.end()); - if (enumIt->second.members.empty()) + if (enumIt->second.values.empty()) { // there are no bits in this flag -> provide the default os << " = " << commandData.params[i].pureType << "()"; @@ -3131,16 +3364,7 @@ void writeFunctionHeaderArgumentsEnhanced(std::ostream & os, VkData const& vkDat argEncountered = true; } } - - os << (returnsVector ? ", " : " "); - } - - if (returnsVector) - { - os << "Allocator const & alloc "; - if (withDefaults) { - os << "= Allocator() "; - } + os << " "; } } @@ -3462,9 +3686,9 @@ void writeTypeCommand(std::ostream & os, VkData const& vkData, DependencyData co auto deleterTypesIt = vkData.deleterTypes.find(""); assert((deleterTypesIt != vkData.deleterTypes.end()) && (deleterTypesIt->second.size() == 1)); - writeDeleterForwardDeclarations(os, *deleterTypesIt, vkData.deleterData); + writeDeleterForwardDeclarations(os, *deleterTypesIt, vkData.deleters); writeTypeCommand(os, " ", vkData, commandData, false); - writeDeleterClasses(os, *deleterTypesIt, vkData.deleterData); + writeDeleterClasses(os, *deleterTypesIt, vkData.deleters); } else { @@ -3506,7 +3730,7 @@ void writeTypeCommand(std::ostream & os, std::string const& indentation, VkData bool specialWriteUnique = (commandData.reducedName == "createDevice") || (commandData.reducedName == "createInstance"); // and then the same for the Unique* versions (a Deleter is available for the commandData's class, and the function starts with 'allocate' or 'create') - if (((vkData.deleterData.find(commandData.className) != vkData.deleterData.end()) || specialWriteUnique) && ((commandData.reducedName.substr(0, 8) == "allocate") || (commandData.reducedName.substr(0, 6) == "create"))) + if (((vkData.deleters.find(commandData.className) != vkData.deleters.end()) || specialWriteUnique) && ((commandData.reducedName.substr(0, 8) == "allocate") || (commandData.reducedName.substr(0, 6) == "create"))) { enhanced << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl; writeFunction(enhanced, indentation, vkData, commandData, definition, true, false, true, false); @@ -3530,16 +3754,28 @@ void writeTypeEnum( std::ostream & os, EnumData const& enumData ) enterProtect(os, enumData.protect); os << " enum class " << enumData.name << std::endl << " {" << std::endl; - for ( size_t i=0 ; i> const& deleterTypes, std::map const& deleterData) +void writeDeleterClasses(std::ostream & os, std::pair> const& deleterTypes, std::map const& deleters) { // A Deleter class for each of the Unique* classes... but only if smart handles are not switched off os << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl; @@ -3647,8 +3883,8 @@ void writeDeleterClasses(std::ostream & os, std::pairsecond.pool.empty() ? "" : startLowerCase(dd->second.pool)); if (poolName.empty()) { @@ -3748,7 +3984,7 @@ void writeDeleterClasses(std::ostream & os, std::pair> const& deleterTypes, std::map const& deleterData) +void writeDeleterForwardDeclarations(std::ostream &os, std::pair> const& deleterTypes, std::map const& deleters) { // if smart handles are supported, all the Deleter classes need to be forward declared os << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl; @@ -3767,9 +4003,9 @@ void writeEnumsToString(std::ostream & os, EnumData const& enumData) { // the helper functions to make strings out of enum values enterProtect(os, enumData.protect); - os << " VULKAN_HPP_INLINE std::string to_string(" << enumData.name << (enumData.members.empty() ? ")" : " value)") << std::endl + os << " VULKAN_HPP_INLINE std::string to_string(" << enumData.name << (enumData.values.empty() ? ")" : " value)") << std::endl << " {" << std::endl; - if (enumData.members.empty()) + if (enumData.values.empty()) { // no enum values in this enum -> return "(void)" os << " return \"(void)\";" << std::endl; @@ -3779,9 +4015,9 @@ void writeEnumsToString(std::ostream & os, EnumData const& enumData) // otherwise switch over the value and return the a stringized version of that value (without leading 'e') os << " switch (value)" << std::endl << " {" << std::endl; - for (auto const& member : enumData.members) + for (auto const& value : enumData.values) { - os << " case " << enumData.name << "::" << member.name << ": return \"" << member.name.substr(1) << "\";" << std::endl; + os << " case " << enumData.name << "::" << value.name << ": return \"" << value.name.substr(1) << "\";" << std::endl; } os << " default: return \"invalid\";" << std::endl << " }" << std::endl; @@ -3795,9 +4031,9 @@ void writeFlagsToString(std::ostream & os, std::string const& flagsName, EnumDat { // the helper functions to make strings out of flag values enterProtect(os, enumData.protect); - os << " VULKAN_HPP_INLINE std::string to_string(" << flagsName << (enumData.members.empty() ? ")" : " value)") << std::endl + os << " VULKAN_HPP_INLINE std::string to_string(" << flagsName << (enumData.values.empty() ? ")" : " value)") << std::endl << " {" << std::endl; - if (enumData.members.empty()) + if (enumData.values.empty()) { // no flags values in this enum -> return "{}" os << " return \"{}\";" << std::endl; @@ -3808,9 +4044,9 @@ void writeFlagsToString(std::ostream & os, std::string const& flagsName, EnumDat << " std::string result;" << std::endl; // 'or' together all the bits in the value - for (auto itMember = enumData.members.begin(); itMember != enumData.members.end(); ++itMember) + for (auto valuesIt = enumData.values.begin(); valuesIt != enumData.values.end(); ++valuesIt) { - os << " if (value & " << enumData.name << "::" << itMember->name << ") result += \"" << itMember->name.substr(1) << " | \";" << std::endl; + os << " if (value & " << enumData.name << "::" << valuesIt->name << ") result += \"" << valuesIt->name.substr(1) << " | \";" << std::endl; } // cut off the last three characters from the result (being " | ") os << " return \"{\" + result.substr(0, result.size() - 3) + \"}\";" << std::endl; @@ -3827,16 +4063,16 @@ void writeTypeFlags(std::ostream & os, std::string const& flagsName, FlagData co os << " using " << flagsName << " = Flags<" << enumData.name << ", Vk" << flagsName << ">;" << std::endl; std::stringstream allFlags; - for (size_t i = 0; i < enumData.members.size(); i++) + for (size_t i = 0; i < enumData.values.size(); i++) { if (i != 0) { allFlags << " | "; } - allFlags << "VkFlags(" << enumData.name << "::" << enumData.members[i].name << ")"; + allFlags << "VkFlags(" << enumData.name << "::" << enumData.values[i].name << ")"; } - if (!enumData.members.empty()) + if (!enumData.values.empty()) { const std::string templateString = R"( VULKAN_HPP_INLINE ${flagsName} operator|( ${enumName} bit0, ${enumName} bit1 ) @@ -3859,6 +4095,13 @@ void writeTypeFlags(std::ostream & os, std::string const& flagsName, FlagData co )"; os << replaceWithMap(templateString, { { "flagsName", flagsName}, { "enumName", enumData.name }, { "allFlags", allFlags.str() } } ); } + + if (!flagData.alias.empty()) + { + os << std::endl + << " using " << flagData.alias << " = " << flagsName << ";" << std::endl; + } + leaveProtect(os, flagData.protect); os << std::endl; } @@ -3883,7 +4126,7 @@ void writeTypeHandle(std::ostream & os, VkData const& vkData, DependencyData con std::map>::const_iterator deleterTypesIt = vkData.deleterTypes.find(dependencyData.name); if (deleterTypesIt != vkData.deleterTypes.end()) { - writeDeleterForwardDeclarations(os, *deleterTypesIt, vkData.deleterData); + writeDeleterForwardDeclarations(os, *deleterTypesIt, vkData.deleters); } const std::string memberName = startLowerCase(dependencyData.name); @@ -3973,11 +4216,17 @@ ${commands} { "commands", commands.str() } }); + if (!handleData.alias.empty()) + { + os << std::endl + << " using " << handleData.alias << " = " << dependencyData.name << ";" << std::endl; + } + // then the actual Deleter classes can be listed deleterTypesIt = vkData.deleterTypes.find(dependencyData.name); if (deleterTypesIt != vkData.deleterTypes.end()) { - writeDeleterClasses(os, *deleterTypesIt, vkData.deleterData); + writeDeleterClasses(os, *deleterTypesIt, vkData.deleters); } // and finally the commands, that are member functions of this handle @@ -4105,6 +4354,12 @@ void writeTypeStruct( std::ostream & os, VkData const& vkData, DependencyData co os << " };" << std::endl << " static_assert( sizeof( " << dependencyData.name << " ) == sizeof( Vk" << dependencyData.name << " ), \"struct and wrapper have different size!\" );" << std::endl; + if (!it->second.alias.empty()) + { + os << std::endl + << " using " << it->second.alias << " = " << it->first << ";" << std::endl; + } + leaveProtect(os, it->second.protect); os << std::endl; } @@ -4347,6 +4602,10 @@ int main( int argc, char **argv ) { readExtensions(child, vkData); } + else if (value == "feature") + { + readFeature(child, vkData.enums); + } else if (value == "tags") { readTags(child, vkData.tags); @@ -4357,7 +4616,7 @@ int main( int argc, char **argv ) } else { - assert((value == "feature") || (value == "vendorids")); + assert(value == "vendorids"); } } diff --git a/tinyxml2 b/tinyxml2 index c8dad95..8b83b23 160000 --- a/tinyxml2 +++ b/tinyxml2 @@ -1 +1 @@ -Subproject commit c8dad95d4488663c0381d502b3274df7dbf2fc55 +Subproject commit 8b83b238767ca1fdaaf73b3f4a1b98c4512a54bb diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 2411547..3631d0a 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -33,7 +33,7 @@ # include # include #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -static_assert( VK_HEADER_VERSION == 62 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 64 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -542,7 +542,8 @@ namespace VULKAN_HPP_NAMESPACE eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT, eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, - eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR + eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, + eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT }; VULKAN_HPP_INLINE std::string to_string(Result value) @@ -576,6 +577,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV"; case Result::eErrorOutOfPoolMemoryKHR: return "ErrorOutOfPoolMemoryKHR"; case Result::eErrorInvalidExternalHandleKHR: return "ErrorInvalidExternalHandleKHR"; + case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT"; default: return "invalid"; } } @@ -820,6 +822,14 @@ namespace VULKAN_HPP_NAMESPACE InvalidExternalHandleKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {} }; + class NotPermittedEXTError : public SystemError + { + public: + NotPermittedEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {} + NotPermittedEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {} + }; VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) { @@ -846,6 +856,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message ); case Result::eErrorOutOfPoolMemoryKHR: throw OutOfPoolMemoryKHRError ( message ); case Result::eErrorInvalidExternalHandleKHR: throw InvalidExternalHandleKHRError ( message ); + case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message ); default: throw SystemError( make_error_code( result ) ); } } @@ -5557,6 +5568,35 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); + struct ShaderResourceUsageAMD + { + operator const VkShaderResourceUsageAMD&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ShaderResourceUsageAMD const& rhs ) const + { + return ( numUsedVgprs == rhs.numUsedVgprs ) + && ( numUsedSgprs == rhs.numUsedSgprs ) + && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) + && ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) + && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); + } + + bool operator!=( ShaderResourceUsageAMD const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; + }; + static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" ); + enum class ImageLayout { eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, @@ -6887,7 +6927,8 @@ namespace VULKAN_HPP_NAMESPACE eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, - eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT + eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, + eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT }; struct ApplicationInfo @@ -15140,6 +15181,39 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); + struct ShaderStatisticsInfoAMD + { + operator const VkShaderStatisticsInfoAMD&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ShaderStatisticsInfoAMD const& rhs ) const + { + return ( shaderStageMask == rhs.shaderStageMask ) + && ( resourceUsage == rhs.resourceUsage ) + && ( numPhysicalVgprs == rhs.numPhysicalVgprs ) + && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) + && ( numAvailableVgprs == rhs.numAvailableVgprs ) + && ( numAvailableSgprs == rhs.numAvailableSgprs ) + && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ); + } + + bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const + { + return !operator==( rhs ); + } + + ShaderStageFlags shaderStageMask; + ShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; + }; + static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" ); + enum class ImageUsageFlagBits { eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, @@ -25574,10 +25648,82 @@ namespace VULKAN_HPP_NAMESPACE eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT }; + enum class ShaderInfoTypeAMD + { + eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD, + eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD, + eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD + }; + + enum class QueueGlobalPriorityEXT + { + eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW, + eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, + eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH, + eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME + }; + + struct DeviceQueueGlobalPriorityCreateInfoEXT + { + DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow ) + : sType( StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT ) + , pNext( nullptr ) + , globalPriority( globalPriority_ ) + { + } + + DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) ); + } + + DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) ); + return *this; + } + DeviceQueueGlobalPriorityCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceQueueGlobalPriorityCreateInfoEXT& setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ ) + { + globalPriority = globalPriority_; + return *this; + } + + operator const VkDeviceQueueGlobalPriorityCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( globalPriority == rhs.globalPriority ); + } + + bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + QueueGlobalPriorityEXT globalPriority; + }; + static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" ); + Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ); #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type enumerateInstanceLayerProperties(Allocator const & alloc = Allocator() ); + typename ResultValueType>::type enumerateInstanceLayerProperties(); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) @@ -25586,9 +25732,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceLayerProperties(Allocator const & alloc ) + VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceLayerProperties() { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; Result result; do @@ -25610,7 +25756,7 @@ namespace VULKAN_HPP_NAMESPACE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ); #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName = nullptr, Allocator const & alloc = Allocator() ); + typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName = nullptr ); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) @@ -25619,9 +25765,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName, Allocator const & alloc ) + VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName ) { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; Result result; do @@ -26856,7 +27002,7 @@ namespace VULKAN_HPP_NAMESPACE void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - std::vector getImageSparseMemoryRequirements( Image image, Allocator const & alloc = Allocator() ) const; + std::vector getImageSparseMemoryRequirements( Image image ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const; @@ -27029,7 +27175,7 @@ namespace VULKAN_HPP_NAMESPACE Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getPipelineCacheData( PipelineCache pipelineCache, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getPipelineCacheData( PipelineCache pipelineCache ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches ) const; @@ -27040,11 +27186,11 @@ namespace VULKAN_HPP_NAMESPACE Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr ) const; ResultValueType::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator = nullptr ) const; #ifndef VULKAN_HPP_NO_SMART_HANDLE template > - std::vector createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Allocator const & alloc = Allocator() ) const; + std::vector createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr ) const; UniquePipeline createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator = nullptr ) const; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -27052,11 +27198,11 @@ namespace VULKAN_HPP_NAMESPACE Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr ) const; ResultValueType::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator = nullptr ) const; #ifndef VULKAN_HPP_NO_SMART_HANDLE template > - std::vector createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Allocator const & alloc = Allocator() ) const; + std::vector createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr ) const; UniquePipeline createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator = nullptr ) const; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -27127,10 +27273,10 @@ namespace VULKAN_HPP_NAMESPACE Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo ) const; #ifndef VULKAN_HPP_NO_SMART_HANDLE template > - std::vector allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const & alloc = Allocator() ) const; + std::vector allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo ) const; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -27197,10 +27343,10 @@ namespace VULKAN_HPP_NAMESPACE Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo ) const; #ifndef VULKAN_HPP_NO_SMART_HANDLE template > - std::vector allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const & alloc = Allocator() ) const; + std::vector allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo ) const; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -27212,11 +27358,11 @@ namespace VULKAN_HPP_NAMESPACE Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator = nullptr, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator = nullptr ) const; ResultValueType::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr ) const; #ifndef VULKAN_HPP_NO_SMART_HANDLE template > - std::vector createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator = nullptr, Allocator const & alloc = Allocator() ) const; + std::vector createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator = nullptr ) const; UniqueSwapchainKHR createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr ) const; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -27237,7 +27383,7 @@ namespace VULKAN_HPP_NAMESPACE Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getSwapchainImagesKHR( SwapchainKHR swapchain ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex ) const; @@ -27456,7 +27602,7 @@ namespace VULKAN_HPP_NAMESPACE Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const; @@ -27476,7 +27622,7 @@ namespace VULKAN_HPP_NAMESPACE void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - std::vector getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info, Allocator const & alloc = Allocator() ) const; + std::vector getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversionKHR* pYcbcrConversion ) const; @@ -27508,7 +27654,7 @@ namespace VULKAN_HPP_NAMESPACE Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches ) const; @@ -27516,6 +27662,12 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy srcCaches ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template > + typename ResultValueType>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const @@ -28219,9 +28371,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements( Image image, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements( Image image ) const { - std::vector sparseMemoryRequirements( {alloc} ); + std::vector sparseMemoryRequirements; uint32_t sparseMemoryRequirementCount; vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, nullptr ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); @@ -28648,9 +28800,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineCacheData( PipelineCache pipelineCache ) const { - std::vector data( {alloc} ); + std::vector data; size_t dataSize; Result result; do @@ -28686,9 +28838,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator ) const { - std::vector pipelines( createInfos.size(), {}, {alloc} ); + std::vector pipelines( createInfos.size() ); Result result = static_cast( vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); return createResultValue( result, pipelines, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelines" ); } @@ -28700,10 +28852,10 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_INLINE std::vector Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator ) const { PipelineDeleter deleter( *this, allocator ); - std::vector pipelines = createGraphicsPipelines( pipelineCache, createInfos, allocator, alloc ); + std::vector pipelines = createGraphicsPipelines( pipelineCache, createInfos, allocator ); std::vector uniquePipelines; uniquePipelines.reserve( pipelines.size() ); for ( auto pipeline : pipelines ) @@ -28726,9 +28878,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator ) const { - std::vector pipelines( createInfos.size(), {}, {alloc} ); + std::vector pipelines( createInfos.size() ); Result result = static_cast( vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); return createResultValue( result, pipelines, "VULKAN_HPP_NAMESPACE::Device::createComputePipelines" ); } @@ -28740,10 +28892,10 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_INLINE std::vector Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator ) const { PipelineDeleter deleter( *this, allocator ); - std::vector pipelines = createComputePipelines( pipelineCache, createInfos, allocator, alloc ); + std::vector pipelines = createComputePipelines( pipelineCache, createInfos, allocator ); std::vector uniquePipelines; uniquePipelines.reserve( pipelines.size() ); for ( auto pipeline : pipelines ) @@ -28914,18 +29066,18 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo ) const { - std::vector descriptorSets( allocateInfo.descriptorSetCount, {}, {alloc} ); + std::vector descriptorSets( allocateInfo.descriptorSetCount ); Result result = static_cast( vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); return createResultValue( result, descriptorSets, "VULKAN_HPP_NAMESPACE::Device::allocateDescriptorSets" ); } #ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_INLINE std::vector Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo ) const { DescriptorSetDeleter deleter( *this, allocateInfo.descriptorPool ); - std::vector descriptorSets = allocateDescriptorSets( allocateInfo, alloc ); + std::vector descriptorSets = allocateDescriptorSets( allocateInfo ); std::vector uniqueDescriptorSets; uniqueDescriptorSets.reserve( descriptorSets.size() ); for ( auto descriptorSet : descriptorSets ) @@ -29085,18 +29237,18 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo ) const { - std::vector commandBuffers( allocateInfo.commandBufferCount, {}, {alloc} ); + std::vector commandBuffers( allocateInfo.commandBufferCount ); Result result = static_cast( vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); return createResultValue( result, commandBuffers, "VULKAN_HPP_NAMESPACE::Device::allocateCommandBuffers" ); } #ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_INLINE std::vector Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo ) const { CommandBufferDeleter deleter( *this, allocateInfo.commandPool ); - std::vector commandBuffers = allocateCommandBuffers( allocateInfo, alloc ); + std::vector commandBuffers = allocateCommandBuffers( allocateInfo ); std::vector uniqueCommandBuffers; uniqueCommandBuffers.reserve( commandBuffers.size() ); for ( auto commandBuffer : commandBuffers ) @@ -29125,9 +29277,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator ) const { - std::vector swapchains( createInfos.size(), {}, {alloc} ); + std::vector swapchains( createInfos.size() ); Result result = static_cast( vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( swapchains.data() ) ) ); return createResultValue( result, swapchains, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainsKHR" ); } @@ -29139,10 +29291,10 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_INLINE std::vector Device::createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector Device::createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator ) const { SwapchainKHRDeleter deleter( *this, allocator ); - std::vector swapchainKHRs = createSharedSwapchainsKHR( createInfos, allocator, alloc ); + std::vector swapchainKHRs = createSharedSwapchainsKHR( createInfos, allocator ); std::vector uniqueSwapchainKHRs; uniqueSwapchainKHRs.reserve( swapchainKHRs.size() ); for ( auto swapchainKHR : swapchainKHRs ) @@ -29196,9 +29348,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain ) const { - std::vector swapchainImages( {alloc} ); + std::vector swapchainImages; uint32_t swapchainImageCount; Result result; do @@ -29753,9 +29905,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const { - std::vector presentationTimings( {alloc} ); + std::vector presentationTimings; uint32_t presentationTimingCount; Result result = static_cast( vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, nullptr ) ); if ( ( result == Result::eSuccess ) && presentationTimingCount ) @@ -29815,9 +29967,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const { - std::vector sparseMemoryRequirements( {alloc} ); + std::vector sparseMemoryRequirements; uint32_t sparseMemoryRequirementCount; vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); @@ -29894,9 +30046,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache ) const { - std::vector data( {alloc} ); + std::vector data; size_t dataSize; Result result; do @@ -29926,6 +30078,32 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const + { + return static_cast( vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), pInfoSize, pInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType ) const + { + std::vector info; + size_t infoSize; + Result result; + do + { + result = static_cast( vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), &infoSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && infoSize ) + { + info.resize( infoSize ); + result = static_cast( vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), &infoSize, reinterpret_cast( info.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + assert( infoSize <= info.size() ); + info.resize( infoSize ); + return createResultValue( result, info, "VULKAN_HPP_NAMESPACE::Device::getShaderInfoAMD" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifndef VULKAN_HPP_NO_SMART_HANDLE class DeviceDeleter; using UniqueDevice = UniqueHandle; @@ -29983,7 +30161,7 @@ namespace VULKAN_HPP_NAMESPACE void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - std::vector getQueueFamilyProperties(Allocator const & alloc = Allocator() ) const; + std::vector getQueueFamilyProperties() const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties ) const; @@ -30017,43 +30195,43 @@ namespace VULKAN_HPP_NAMESPACE Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type enumerateDeviceLayerProperties(Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type enumerateDeviceLayerProperties() const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type enumerateDeviceExtensionProperties( Optional layerName = nullptr, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type enumerateDeviceExtensionProperties( Optional layerName = nullptr ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - std::vector getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const & alloc = Allocator() ) const; + std::vector getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getDisplayPropertiesKHR(Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getDisplayPropertiesKHR() const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getDisplayPlanePropertiesKHR(Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getDisplayPlanePropertiesKHR() const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getDisplayModePropertiesKHR( DisplayKHR display, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getDisplayModePropertiesKHR( DisplayKHR display ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode ) const; @@ -30086,13 +30264,13 @@ namespace VULKAN_HPP_NAMESPACE Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getSurfaceFormatsKHR( SurfaceKHR surface ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getSurfacePresentModesKHR( SurfaceKHR surface ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VK_USE_PLATFORM_WAYLAND_KHR @@ -30159,7 +30337,7 @@ namespace VULKAN_HPP_NAMESPACE void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2KHR* pQueueFamilyProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - std::vector getQueueFamilyProperties2KHR(Allocator const & alloc = Allocator() ) const; + std::vector getQueueFamilyProperties2KHR() const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2KHR* pMemoryProperties ) const; @@ -30170,7 +30348,7 @@ namespace VULKAN_HPP_NAMESPACE void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2KHR* pProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - std::vector getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo, Allocator const & alloc = Allocator() ) const; + std::vector getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const; @@ -30216,7 +30394,7 @@ namespace VULKAN_HPP_NAMESPACE Result getPresentRectanglesKHX( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getPresentRectanglesKHX( SurfaceKHR surface, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getPresentRectanglesKHX( SurfaceKHR surface ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties ) const; @@ -30234,7 +30412,7 @@ namespace VULKAN_HPP_NAMESPACE Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -30297,9 +30475,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties(Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties() const { - std::vector queueFamilyProperties( {alloc} ); + std::vector queueFamilyProperties; uint32_t queueFamilyPropertyCount; vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); queueFamilyProperties.resize( queueFamilyPropertyCount ); @@ -30386,9 +30564,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceLayerProperties(Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceLayerProperties() const { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; Result result; do @@ -30412,9 +30590,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName ) const { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; Result result; do @@ -30438,9 +30616,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( samples ), static_cast( usage ), static_cast( tiling ), &propertyCount, nullptr ); properties.resize( propertyCount ); @@ -30455,9 +30633,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPropertiesKHR(Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPropertiesKHR() const { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; Result result; do @@ -30481,9 +30659,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlanePropertiesKHR() const { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; Result result; do @@ -30507,9 +30685,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const { - std::vector displays( {alloc} ); + std::vector displays; uint32_t displayCount; Result result; do @@ -30533,9 +30711,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display ) const { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; Result result; do @@ -30624,9 +30802,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface ) const { - std::vector surfaceFormats( {alloc} ); + std::vector surfaceFormats; uint32_t surfaceFormatCount; Result result; do @@ -30650,9 +30828,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface ) const { - std::vector presentModes( {alloc} ); + std::vector presentModes; uint32_t presentModeCount; Result result; do @@ -30824,9 +31002,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR(Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR() const { - std::vector queueFamilyProperties( {alloc} ); + std::vector queueFamilyProperties; uint32_t queueFamilyPropertyCount; vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); queueFamilyProperties.resize( queueFamilyPropertyCount ); @@ -30854,9 +31032,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo, Allocator const & alloc ) const + VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const { - std::vector properties( {alloc} ); + std::vector properties; uint32_t propertyCount; vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); properties.resize( propertyCount ); @@ -30966,9 +31144,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getPresentRectanglesKHX( SurfaceKHR surface, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getPresentRectanglesKHX( SurfaceKHR surface ) const { - std::vector rects( {alloc} ); + std::vector rects; uint32_t rectCount; Result result; do @@ -31026,9 +31204,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const { - std::vector surfaceFormats( {alloc} ); + std::vector surfaceFormats; uint32_t surfaceFormatCount; Result result; do @@ -31275,7 +31453,7 @@ namespace VULKAN_HPP_NAMESPACE Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type enumeratePhysicalDevices(Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type enumeratePhysicalDevices() const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ PFN_vkVoidFunction getProcAddr( const char* pName ) const; @@ -31387,7 +31565,7 @@ namespace VULKAN_HPP_NAMESPACE Result enumeratePhysicalDeviceGroupsKHX( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template > - typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHX(Allocator const & alloc = Allocator() ) const; + typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHX() const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VK_USE_PLATFORM_IOS_MVK @@ -31488,9 +31666,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDevices(Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDevices() const { - std::vector physicalDevices( {alloc} ); + std::vector physicalDevices; uint32_t physicalDeviceCount; Result result; do @@ -31760,9 +31938,9 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroupsKHX(Allocator const & alloc ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroupsKHX() const { - std::vector physicalDeviceGroupProperties( {alloc} ); + std::vector physicalDeviceGroupProperties; uint32_t physicalDeviceGroupCount; Result result; do @@ -32044,6 +32222,7 @@ namespace VULKAN_HPP_NAMESPACE template <> constexpr bool isStructureChainValid() { return true; } template <> constexpr bool isStructureChainValid() { return true; } template <> constexpr bool isStructureChainValid() { return true; } + template <> constexpr bool isStructureChainValid() { return true; } template <> constexpr bool isStructureChainValid() { return true; } VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits) { @@ -33430,6 +33609,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eBindImageMemoryInfoKHR: return "BindImageMemoryInfoKHR"; case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT"; case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT"; + case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT"; default: return "invalid"; } } @@ -35071,6 +35251,29 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_INLINE std::string to_string(ShaderInfoTypeAMD value) + { + switch (value) + { + case ShaderInfoTypeAMD::eStatistics: return "Statistics"; + case ShaderInfoTypeAMD::eBinary: return "Binary"; + case ShaderInfoTypeAMD::eDisassembly: return "Disassembly"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(QueueGlobalPriorityEXT value) + { + switch (value) + { + case QueueGlobalPriorityEXT::eLow: return "Low"; + case QueueGlobalPriorityEXT::eMedium: return "Medium"; + case QueueGlobalPriorityEXT::eHigh: return "High"; + case QueueGlobalPriorityEXT::eRealtime: return "Realtime"; + default: return "invalid"; + } + } + } // namespace VULKAN_HPP_NAMESPACE #endif