mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Update to Vulkan 1.0.66 (#158)

Browse Source 
- Add support for the new alias tag
This commit is contained in:
Markus Tavenrath 2017-12-04 14:27:47 +01:00 committed by Andreas Süßenbach
parent 05bd56f8c5
commit 047961e987
3 changed files with 5201 additions and 4896 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Docs

@ -1 +1 @@
Subproject commit 25f952fe85f5a8bb9e166e9e026f1de081b684af Subproject commit 2f5bc66d7adcf5bda62bb2e3666e36992b93792d

236
VulkanHppGenerator.cpp
View File

@ -754,6 +754,7 @@ struct DependencyData
{ {
enum class Category enum class Category
{ {
ALIAS,
COMMAND, COMMAND,
ENUM, ENUM,
FLAGS, FLAGS,
@ -776,6 +777,19 @@ struct DependencyData
std::set<std::string> forwardDependencies; std::set<std::string> forwardDependencies;
}; };
struct AliasData
{
AliasData(DependencyData::Category c, std::string const& v, std::string const& p)
: category(c)
, value(v)
, protect(p)
{}
DependencyData::Category category;
std::string value;
std::string protect;
};
struct EnumValueData struct EnumValueData
{ {
std::string name; std::string name;
@ -798,7 +812,6 @@ struct EnumData
std::vector<EnumValueData> values; std::vector<EnumValueData> values;
std::string protect; std::string protect;
bool bitmask; bool bitmask;
std::string alias;
}; };
struct FlagData struct FlagData
@ -839,7 +852,6 @@ struct StructData
std::vector<MemberData> members; std::vector<MemberData> members;
std::string protect; std::string protect;
std::vector<std::string> structExtends; std::vector<std::string> structExtends;
std::string alias;
}; };
struct DeleterData struct DeleterData
@ -865,6 +877,7 @@ struct VendorIDData
struct VkData struct VkData
{ {
std::map<std::string, AliasData> aliases; // Enum Aliases
std::map<std::string, CommandData> commands; std::map<std::string, CommandData> commands;
std::map<std::string, std::string> constants; std::map<std::string, std::string> constants;
std::set<std::string> defines; std::set<std::string> defines;
@ -889,7 +902,7 @@ struct VkData
#endif #endif
}; };
void aliasEnum(VkData & vkData, std::map<std::string, EnumData>::iterator enumsIt, std::string const& newName, std::string const& protect); void aliasType(VkData & vkData, DependencyData::Category category, std::string const& aliasName, std::string const& newName, std::string const& protect);
void createDefaults( VkData const& vkData, std::map<std::string,std::string> & defaultValues ); void createDefaults( VkData const& vkData, std::map<std::string,std::string> & defaultValues );
void determineEnhancedReturnType(CommandData & commandData); void determineEnhancedReturnType(CommandData & commandData);
void determineReducedName(CommandData & commandData); void determineReducedName(CommandData & commandData);
@ -928,11 +941,11 @@ void readFeature(tinyxml2::XMLElement * element, std::map<std::string, EnumData>
void readFeatureRequire(tinyxml2::XMLElement * element, std::map<std::string, EnumData> & enums, std::map<std::string, std::string> & nameMap); void readFeatureRequire(tinyxml2::XMLElement * element, std::map<std::string, EnumData> & enums, std::map<std::string, std::string> & nameMap);
void readFeatureRequireEnum(tinyxml2::XMLElement * element, std::map<std::string, EnumData> & enums, std::map<std::string, std::string> & nameMap); void readFeatureRequireEnum(tinyxml2::XMLElement * element, std::map<std::string, EnumData> & enums, std::map<std::string, std::string> & nameMap);
tinyxml2::XMLNode* readType(tinyxml2::XMLNode* element, std::string & type, std::string & pureType); tinyxml2::XMLNode* readType(tinyxml2::XMLNode* element, std::string & type, std::string & pureType);
void readTypeBasetype( tinyxml2::XMLElement * element, std::list<DependencyData> & dependencies ); void readTypeBasetype(tinyxml2::XMLElement * element, std::list<DependencyData> & dependencies, std::map<std::string, std::string> const& attributes);
void readTypeBitmask( tinyxml2::XMLElement * element, VkData & vkData); void readTypeBitmask(tinyxml2::XMLElement * element, VkData & vkData, std::map<std::string, std::string> const& attributes);
void readTypeDefine( tinyxml2::XMLElement * element, VkData & vkData ); void readTypeDefine(tinyxml2::XMLElement * element, VkData & vkData, std::map<std::string, std::string> const& attributes);
void readTypeFuncpointer( tinyxml2::XMLElement * element, std::list<DependencyData> & dependencies ); void readTypeFuncpointer( tinyxml2::XMLElement * element, std::list<DependencyData> & dependencies );
void readTypeHandle(tinyxml2::XMLElement * element, VkData & vkData); void readTypeHandle(tinyxml2::XMLElement * element, VkData & vkData, std::map<std::string, std::string> const& attributes);
void readTypeStruct( tinyxml2::XMLElement * element, VkData & vkData, bool isUnion ); void readTypeStruct( tinyxml2::XMLElement * element, VkData & vkData, bool isUnion );
void readTypeStructMember( tinyxml2::XMLElement * element, VkData & vkData, StructData & structData ); void readTypeStructMember( tinyxml2::XMLElement * element, VkData & vkData, StructData & structData );
void readTag(tinyxml2::XMLElement * element, std::set<std::string> & tags); void readTag(tinyxml2::XMLElement * element, std::set<std::string> & tags);
@ -955,7 +968,6 @@ std::string trimEnd(std::string const& input);
void writeCall(std::ostream & os, CommandData const& commandData, std::set<std::string> const& vkTypes, bool firstCall, bool singular); void writeCall(std::ostream & os, CommandData const& commandData, std::set<std::string> const& vkTypes, bool firstCall, bool singular);
std::string generateCall(CommandData const& commandData, std::set<std::string> const& vkTypes, bool firstCall, bool singular); std::string generateCall(CommandData const& commandData, std::set<std::string> const& vkTypes, bool firstCall, bool singular);
void writeCallCountParameter(std::ostream & os, CommandData const& commandData, bool singular, std::map<size_t, size_t>::const_iterator it); void writeCallCountParameter(std::ostream & os, CommandData const& commandData, bool singular, std::map<size_t, size_t>::const_iterator it);
void writeCallParameter(std::ostream & os, ParamData const& paramData, std::set<std::string> const& vkTypes);
void writeCallPlainTypeParameter(std::ostream & os, ParamData const& paramData); void writeCallPlainTypeParameter(std::ostream & os, ParamData const& paramData);
void writeCallVectorParameter(std::ostream & os, CommandData const& commandData, std::set<std::string> const& vkTypes, bool firstCall, bool singular, std::map<size_t, size_t>::const_iterator it); void writeCallVectorParameter(std::ostream & os, CommandData const& commandData, std::set<std::string> const& vkTypes, bool firstCall, bool singular, std::map<size_t, size_t>::const_iterator it);
void writeCallVulkanTypeParameter(std::ostream & os, ParamData const& paramData); void writeCallVulkanTypeParameter(std::ostream & os, ParamData const& paramData);
@ -986,6 +998,7 @@ void writeReinterpretCast(std::ostream & os, bool leadingConst, bool vulkanType,
void writeStandardOrEnhanced(std::ostream & os, std::string const& standard, std::string const& enhanced); void writeStandardOrEnhanced(std::ostream & os, std::string const& standard, std::string const& enhanced);
void writeStructConstructor( std::ostream & os, std::string const& name, StructData const& structData, std::set<std::string> const& vkTypes, std::map<std::string, std::string> const& nameMap, std::map<std::string,std::string> const& defaultValues ); void writeStructConstructor( std::ostream & os, std::string const& name, StructData const& structData, std::set<std::string> const& vkTypes, std::map<std::string, std::string> const& nameMap, std::map<std::string,std::string> const& defaultValues );
void writeStructSetter( std::ostream & os, std::string const& structureName, MemberData const& memberData, std::set<std::string> const& vkTypes, std::map<std::string,StructData> const& structs ); void writeStructSetter( std::ostream & os, std::string const& structureName, MemberData const& memberData, std::set<std::string> const& vkTypes, std::map<std::string,StructData> const& structs );
void writeTypeAlias(std::ostream & os, VkData const& vkData, DependencyData const& dependencyData);
void writeTypeCommand(std::ostream & os, VkData const& vkData, DependencyData const& dependencyData); void writeTypeCommand(std::ostream & os, VkData const& vkData, DependencyData const& dependencyData);
void writeTypeCommand(std::ostream &os, std::string const& indentation, VkData const& vkData, CommandData const& commandData, bool definition); void writeTypeCommand(std::ostream &os, std::string const& indentation, VkData const& vkData, CommandData const& commandData, bool definition);
void writeTypeEnum(std::ostream & os, EnumData const& enumData); void writeTypeEnum(std::ostream & os, EnumData const& enumData);
@ -1002,6 +1015,7 @@ void writeTypes(std::ostream & os, VkData const& vkData, std::map<std::string, s
void writeVersionCheck(std::ostream & os, std::string const& version); void writeVersionCheck(std::ostream & os, std::string const& version);
void writeTypesafeCheck(std::ostream & os, std::string const& typesafeCheck); void writeTypesafeCheck(std::ostream & os, std::string const& typesafeCheck);
#if !defined(NDEBUG) #if !defined(NDEBUG)
void skipTypeEnum(tinyxml2::XMLElement * element, std::map<std::string, std::string> const& attributes);
void skipTypeInclude(tinyxml2::XMLElement * element, std::map<std::string, std::string> const& attributes); void skipTypeInclude(tinyxml2::XMLElement * element, std::map<std::string, std::string> const& attributes);
void skipVendorID(tinyxml2::XMLElement * element, std::vector<VendorIDData> & vendorIDs); void skipVendorID(tinyxml2::XMLElement * element, std::vector<VendorIDData> & vendorIDs);
void skipVendorIDs(tinyxml2::XMLElement * element, std::vector<VendorIDData> & vendorIDs); void skipVendorIDs(tinyxml2::XMLElement * element, std::vector<VendorIDData> & vendorIDs);
@ -1044,12 +1058,30 @@ void EnumData::addEnumValue(std::string const &name, std::string const& tag, std
} }
} }
void aliasEnum(VkData & vkData, std::map<std::string, EnumData>::iterator enumsIt, std::string const& newName, std::string const& protect) void aliasType(VkData & vkData, DependencyData::Category category, std::string const& aliasName, std::string const& newName, std::string const& protect)
{ {
assert(vkData.enums.find(newName) == vkData.enums.end()); auto aliasIt = vkData.aliases.find(newName);
assert(enumsIt->second.protect == protect); if (aliasIt == vkData.aliases.end())
assert(enumsIt->second.alias.empty()); {
enumsIt->second.alias = newName; vkData.aliases.insert(std::make_pair(newName, AliasData(category, aliasName, protect)));
// we have to add the type to the set of vulkan types to ensure that the require type conversion takes place
vkData.vkTypes.insert(newName);
assert(std::find_if(vkData.dependencies.begin(), vkData.dependencies.end(), [newName](DependencyData const& dd) {return dd.name == newName; }) == vkData.dependencies.end());
vkData.dependencies.push_back(DependencyData(DependencyData::Category::ALIAS, newName));
vkData.dependencies.back().dependencies.insert(aliasName);
}
else
{
assert(aliasIt->second.protect == protect);
auto dependencyIt = std::find_if(vkData.dependencies.begin(), vkData.dependencies.end(), [newName](DependencyData const& dd) {return dd.name == newName; });
assert((dependencyIt != vkData.dependencies.end()) && (dependencyIt->dependencies.size() == 1) && (dependencyIt->dependencies.find(aliasName) != dependencyIt->dependencies.end()));
}
}
static void setDefault(std::string const& name, std::map<std::string, std::string> & defaultValues, EnumData const& enumData)
{
defaultValues[name] = name + (enumData.values.empty() ? "()" : ("::" + enumData.values.front().name));
} }
void createDefaults( VkData const& vkData, std::map<std::string,std::string> & defaultValues ) void createDefaults( VkData const& vkData, std::map<std::string,std::string> & defaultValues )
@ -1059,21 +1091,29 @@ void createDefaults( VkData const& vkData, std::map<std::string,std::string> & d
assert( defaultValues.find( dependency.name ) == defaultValues.end() ); assert( defaultValues.find( dependency.name ) == defaultValues.end() );
switch( dependency.category ) switch( dependency.category )
{ {
case DependencyData::Category::ALIAS:
{
auto aliasIt = vkData.aliases.find(dependency.name);
switch (aliasIt->second.category)
{
case DependencyData::Category::ENUM:
assert((aliasIt != vkData.aliases.end()) && (vkData.enums.find(aliasIt->second.value) != vkData.enums.end()));
setDefault(dependency.name, defaultValues, vkData.enums.find(aliasIt->second.value)->second);
break;
case DependencyData::Category::STRUCT:
defaultValues[dependency.name] = dependency.name + "()";
break;
default:
assert(false);
break;
}
}
break;
case DependencyData::Category::COMMAND : // commands should never be asked for defaults case DependencyData::Category::COMMAND : // commands should never be asked for defaults
break; break;
case DependencyData::Category::ENUM : case DependencyData::Category::ENUM :
{ assert(vkData.enums.find(dependency.name) != vkData.enums.end());
assert(vkData.enums.find(dependency.name) != vkData.enums.end()); setDefault(dependency.name, defaultValues, vkData.enums.find(dependency.name)->second);
EnumData const & enumData = vkData.enums.find(dependency.name)->second;
if (!enumData.values.empty())
{
defaultValues[dependency.name] = dependency.name + "::" + vkData.enums.find(dependency.name)->second.values.front().name;
}
else
{
defaultValues[dependency.name] = dependency.name + "()";
}
}
break; break;
case DependencyData::Category::FLAGS : case DependencyData::Category::FLAGS :
case DependencyData::Category::HANDLE: case DependencyData::Category::HANDLE:
@ -1236,6 +1276,7 @@ void determineVectorParams(CommandData & commandData)
auto findLambda = [it](ParamData const& pd) { return pd.name == it->len; }; auto findLambda = [it](ParamData const& pd) { return pd.name == it->len; };
auto findIt = std::find_if(begin, it, findLambda); // look for a parameter named as the len of this parameter auto findIt = std::find_if(begin, it, findLambda); // look for a parameter named as the len of this parameter
assert((std::count_if(begin, end, findLambda) == 0) || (findIt < it)); // make sure, there is no other parameter like that assert((std::count_if(begin, end, findLambda) == 0) || (findIt < it)); // make sure, there is no other parameter like that
// add this parameter as a vector parameter, using the len-name parameter as the second value (or ~0 if there is nothing like that) // add this parameter as a vector parameter, using the len-name parameter as the second value (or ~0 if there is nothing like that)
commandData.vectorParams.insert(std::make_pair(std::distance(begin, it), findIt < it ? std::distance(begin, findIt) : ~0)); commandData.vectorParams.insert(std::make_pair(std::distance(begin, it), findIt < it ? std::distance(begin, findIt) : ~0));
assert((commandData.vectorParams[std::distance(begin, it)] != ~0) assert((commandData.vectorParams[std::distance(begin, it)] != ~0)
@ -1718,6 +1759,10 @@ void readExtensionAlias(tinyxml2::XMLElement * element, VkData & vkData, std::st
determineReducedName(commandData); determineReducedName(commandData);
vkData.commands.insert(std::make_pair(commandData.fullName, commandData)); vkData.commands.insert(std::make_pair(commandData.fullName, commandData));
linkCommandToHandle(vkData, commandData);
// add an empty DependencyData to this name
vkData.dependencies.push_back(DependencyData(DependencyData::Category::COMMAND, commandData.fullName));
} }
else else
{ {
@ -1738,7 +1783,8 @@ void readExtensionAlias(tinyxml2::XMLElement * element, VkData & vkData, std::st
if (enumsIt != vkData.enums.end()) if (enumsIt != vkData.enums.end())
{ {
// the alias is on an enum -> set the alias, which will map to a using directive // the alias is on an enum -> set the alias, which will map to a using directive
aliasEnum(vkData, enumsIt, strippedName, protect); assert(vkData.enums.find(strippedName) == vkData.enums.end());
aliasType(vkData, DependencyData::Category::ENUM, enumsIt->first, strippedName, protect);
} }
else else
{ {
@ -1756,7 +1802,7 @@ void readExtensionAlias(tinyxml2::XMLElement * element, VkData & vkData, std::st
assert(enumsIt != vkData.enums.end()); assert(enumsIt != vkData.enums.end());
if (enumsIt->second.values.empty()) if (enumsIt->second.values.empty())
{ {
aliasEnum(vkData, enumsIt, generateEnumNameForFlags(flagsIt->second.alias), protect); aliasType(vkData, DependencyData::Category::ENUM, enumsIt->first, generateEnumNameForFlags(flagsIt->second.alias), protect);
} }
} }
else else
@ -1776,9 +1822,7 @@ void readExtensionAlias(tinyxml2::XMLElement * element, VkData & vkData, std::st
{ {
// the alias is on a structure -> set the alias, which will map to a using directive // 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(vkData.structs.find(strippedName) == vkData.structs.end());
assert(structsIt->second.protect == protect); aliasType(vkData, DependencyData::Category::STRUCT, structsIt->first, strippedName, protect);
assert(structsIt->second.alias.empty() || (structsIt->second.alias == strippedName));
structsIt->second.alias = strippedName;
} }
else else
{ {
@ -2050,17 +2094,21 @@ tinyxml2::XMLNode* readType(tinyxml2::XMLNode* element, std::string & type, std:
return element; return element;
} }
void readTypeBasetype( tinyxml2::XMLElement * element, std::list<DependencyData> & dependencies ) void readTypeBasetype(tinyxml2::XMLElement * element, std::list<DependencyData> & dependencies, std::map<std::string, std::string> const& attributes)
{ {
assert((attributes.size() == 1) && (attributes.find("category") != attributes.end()) && (attributes.find("category")->second == "basetype"));
tinyxml2::XMLElement * typeElement = element->FirstChildElement(); tinyxml2::XMLElement * typeElement = element->FirstChildElement();
assert( typeElement && ( strcmp( typeElement->Value(), "type" ) == 0 ) && typeElement->GetText() ); assert(typeElement && !typeElement->FirstAttribute() && (strcmp(typeElement->Value(), "type") == 0) && typeElement->GetText());
std::string type = typeElement->GetText(); std::string type = typeElement->GetText();
assert( ( type == "uint32_t" ) || ( type == "uint64_t" ) ); assert( ( type == "uint32_t" ) || ( type == "uint64_t" ) );
tinyxml2::XMLElement * nameElement = typeElement->NextSiblingElement(); tinyxml2::XMLElement * nameElement = typeElement->NextSiblingElement();
assert( nameElement && ( strcmp( nameElement->Value(), "name" ) == 0 ) && nameElement->GetText() ); assert(nameElement && !nameElement->FirstAttribute() && (strcmp(nameElement->Value(), "name") == 0) && nameElement->GetText());
std::string name = strip( nameElement->GetText(), "Vk" ); std::string name = strip( nameElement->GetText(), "Vk" );
assert(!nameElement->NextSiblingElement());
// skip "Flags", // skip "Flags",
if ( name != "Flags" ) if ( name != "Flags" )
{ {
@ -2073,22 +2121,26 @@ void readTypeBasetype( tinyxml2::XMLElement * element, std::list<DependencyData>
} }
} }
void readTypeBitmask(tinyxml2::XMLElement * element, VkData & vkData) void readTypeBitmask(tinyxml2::XMLElement * element, VkData & vkData, std::map<std::string, std::string> const& attributes)
{ {
assert((attributes.find("category") != attributes.end()) && (attributes.find("category")->second == "bitmask"));
assert((attributes.size() == 1) || ((attributes.size() == 2) && (attributes.find("requires") != attributes.end())));
tinyxml2::XMLElement * typeElement = element->FirstChildElement(); tinyxml2::XMLElement * typeElement = element->FirstChildElement();
assert( typeElement && ( strcmp( typeElement->Value(), "type" ) == 0 ) && typeElement->GetText() && ( strcmp( typeElement->GetText(), "VkFlags" ) == 0 ) ); assert(typeElement && !typeElement->FirstAttribute() && (strcmp(typeElement->Value(), "type") == 0) && typeElement->GetText() && (strcmp(typeElement->GetText(), "VkFlags") == 0));
std::string type = typeElement->GetText(); std::string type = typeElement->GetText();
tinyxml2::XMLElement * nameElement = typeElement->NextSiblingElement(); tinyxml2::XMLElement * nameElement = typeElement->NextSiblingElement();
assert( nameElement && ( strcmp( nameElement->Value(), "name" ) == 0 ) && nameElement->GetText() ); assert(nameElement && !nameElement->FirstAttribute() && (strcmp(nameElement->Value(), "name") == 0) && nameElement->GetText());
std::string name = strip( nameElement->GetText(), "Vk" ); std::string name = strip( nameElement->GetText(), "Vk" );
assert( !nameElement->NextSiblingElement() ); assert( !nameElement->NextSiblingElement() );
std::string requires; std::string requires;
if (element->Attribute("requires")) auto requiresIt = attributes.find("requires");
if (requiresIt != attributes.end())
{ {
requires = strip(element->Attribute("requires"), "Vk"); requires = strip(requiresIt->second, "Vk");
} }
else else
{ {
@ -2109,15 +2161,17 @@ void readTypeBitmask(tinyxml2::XMLElement * element, VkData & vkData)
vkData.vkTypes.insert( name ); vkData.vkTypes.insert( name );
} }
void readTypeDefine( tinyxml2::XMLElement * element, VkData & vkData ) void readTypeDefine(tinyxml2::XMLElement * element, VkData & vkData, std::map<std::string, std::string> const& attributes)
{ {
tinyxml2::XMLElement * child = element->FirstChildElement(); assert((attributes.find("category") != attributes.end()) && (attributes.find("category")->second == "define"));
if (child && (strcmp(child->GetText(), "VK_HEADER_VERSION") == 0)) assert((attributes.size() == 1) || ((attributes.size() == 2) && (attributes.find("name") != attributes.end())));
{
vkData.version = element->LastChild()->ToText()->Value(); auto nameIt = attributes.find("name");
} if (nameIt != attributes.end())
else if (element->Attribute("name") && strcmp(element->Attribute("name"), "VK_DEFINE_NON_DISPATCHABLE_HANDLE") == 0)
{ {
assert(!element->FirstChildElement());
assert(nameIt->second == "VK_DEFINE_NON_DISPATCHABLE_HANDLE");
// filter out the check for the different types of VK_DEFINE_NON_DISPATCHABLE_HANDLE // filter out the check for the different types of VK_DEFINE_NON_DISPATCHABLE_HANDLE
std::string text = element->LastChild()->ToText()->Value(); std::string text = element->LastChild()->ToText()->Value();
size_t start = text.find("#if defined(__LP64__)"); size_t start = text.find("#if defined(__LP64__)");
@ -2126,11 +2180,23 @@ void readTypeDefine( tinyxml2::XMLElement * element, VkData & vkData )
} }
else if (element->GetText() && (trim(element->GetText()) == "struct")) else if (element->GetText() && (trim(element->GetText()) == "struct"))
{ {
tinyxml2::XMLElement * child = element->FirstChildElement();
assert(child && (strcmp(child->Value(), "name") == 0) && child->GetText()); assert(child && (strcmp(child->Value(), "name") == 0) && child->GetText());
vkData.defines.insert(child->GetText()); vkData.defines.insert(child->GetText());
vkData.dependencies.push_back(DependencyData(DependencyData::Category::REQUIRED, child->GetText())); vkData.dependencies.push_back(DependencyData(DependencyData::Category::REQUIRED, child->GetText()));
} }
// ignore all the other defines else
{
tinyxml2::XMLElement * child = element->FirstChildElement();
assert(child && !child->FirstAttribute() && (strcmp(child->Value(), "name") == 0) && child->GetText());
std::string text = trim(child->GetText());
if (text == "VK_HEADER_VERSION")
{
vkData.version = element->LastChild()->ToText()->Value();
}
// ignore all the other defines
assert(!child->NextSiblingElement() || (child->NextSiblingElement() && !child->NextSiblingElement()->FirstAttribute() && (strcmp(child->NextSiblingElement()->Value(), "type") == 0) && !child->NextSiblingElement()->NextSiblingElement()));
}
} }
void readTypeFuncpointer( tinyxml2::XMLElement * element, std::list<DependencyData> & dependencies ) void readTypeFuncpointer( tinyxml2::XMLElement * element, std::list<DependencyData> & dependencies )
@ -2141,17 +2207,20 @@ void readTypeFuncpointer( tinyxml2::XMLElement * element, std::list<DependencyDa
dependencies.push_back( DependencyData( DependencyData::Category::FUNC_POINTER, child->GetText() ) ); dependencies.push_back( DependencyData( DependencyData::Category::FUNC_POINTER, child->GetText() ) );
} }
void readTypeHandle(tinyxml2::XMLElement * element, VkData & vkData) void readTypeHandle(tinyxml2::XMLElement * element, VkData & vkData, std::map<std::string, std::string> const& attributes)
{ {
assert((attributes.find("category") != attributes.end()) && (attributes.find("category")->second == "handle"));
assert((attributes.size() == 1) || ((attributes.size() == 2) && (attributes.find("parent") != attributes.end())));
tinyxml2::XMLElement * typeElement = element->FirstChildElement(); tinyxml2::XMLElement * typeElement = element->FirstChildElement();
assert( typeElement && ( strcmp( typeElement->Value(), "type" ) == 0 ) && typeElement->GetText() ); assert(typeElement && !typeElement->FirstAttribute() && (strcmp(typeElement->Value(), "type") == 0) && typeElement->GetText());
#if !defined(NDEBUG) #if !defined(NDEBUG)
std::string type = typeElement->GetText(); std::string type = typeElement->GetText();
assert((type.find("VK_DEFINE_HANDLE") == 0) || (type.find("VK_DEFINE_NON_DISPATCHABLE_HANDLE") == 0)); assert((type.find("VK_DEFINE_HANDLE") == 0) || (type.find("VK_DEFINE_NON_DISPATCHABLE_HANDLE") == 0));
#endif #endif
tinyxml2::XMLElement * nameElement = typeElement->NextSiblingElement(); tinyxml2::XMLElement * nameElement = typeElement->NextSiblingElement();
assert( nameElement && ( strcmp( nameElement->Value(), "name" ) == 0 ) && nameElement->GetText() ); assert(nameElement && !nameElement->FirstAttribute() && (strcmp(nameElement->Value(), "name") == 0) && nameElement->GetText());
std::string name = strip( nameElement->GetText(), "Vk" ); std::string name = strip( nameElement->GetText(), "Vk" );
vkData.dependencies.push_back( DependencyData( DependencyData::Category::HANDLE, name ) ); vkData.dependencies.push_back( DependencyData( DependencyData::Category::HANDLE, name ) );
@ -2269,15 +2338,21 @@ void readType(tinyxml2::XMLElement * element, VkData & vkData)
{ {
if (categoryIt->second == "basetype") if (categoryIt->second == "basetype")
{ {
readTypeBasetype(element, vkData.dependencies); readTypeBasetype(element, vkData.dependencies, attributes);
} }
else if (categoryIt->second == "bitmask") else if (categoryIt->second == "bitmask")
{ {
readTypeBitmask(element, vkData); readTypeBitmask(element, vkData, attributes);
} }
#if !defined(NDEBUG)
else if (categoryIt->second == "enum")
{
skipTypeEnum(element, attributes);
}
#endif
else if (categoryIt->second == "define") else if (categoryIt->second == "define")
{ {
readTypeDefine(element, vkData); readTypeDefine(element, vkData, attributes);
} }
else if (categoryIt->second == "funcpointer") else if (categoryIt->second == "funcpointer")
{ {
@ -2285,7 +2360,7 @@ void readType(tinyxml2::XMLElement * element, VkData & vkData)
} }
else if (categoryIt->second == "handle") else if (categoryIt->second == "handle")
{ {
readTypeHandle(element, vkData); readTypeHandle(element, vkData, attributes);
} }
#if !defined(NDEBUG) #if !defined(NDEBUG)
else if (categoryIt->second == "include") else if (categoryIt->second == "include")
@ -2303,7 +2378,7 @@ void readType(tinyxml2::XMLElement * element, VkData & vkData)
} }
else else
{ {
assert(categoryIt->second == "enum"); assert(false);
} }
} }
else else
@ -3745,6 +3820,19 @@ void writeStructSetter( std::ostream & os, std::string const& structureName, Mem
} }
} }
void writeTypeAlias(std::ostream & os, VkData const& vkData, DependencyData const& dependencyData)
{
auto aliasIt = vkData.aliases.find(dependencyData.name);
assert(aliasIt != vkData.aliases.end());
assert(((aliasIt->second.category == DependencyData::Category::ENUM) && (vkData.enums.find(aliasIt->second.value) != vkData.enums.end()))
|| ((aliasIt->second.category == DependencyData::Category::STRUCT) && (vkData.structs.find(aliasIt->second.value) != vkData.structs.end())));
enterProtect(os, aliasIt->second.protect);
os << " using " << aliasIt->first << " = " << aliasIt->second.value << ";" << std::endl;
leaveProtect(os, aliasIt->second.protect);
os << std::endl;
}
void writeTypeCommand(std::ostream & os, VkData const& vkData, DependencyData const& dependencyData) void writeTypeCommand(std::ostream & os, VkData const& vkData, DependencyData const& dependencyData)
{ {
assert(vkData.commands.find(dependencyData.name) != vkData.commands.end()); assert(vkData.commands.find(dependencyData.name) != vkData.commands.end());
@ -3841,12 +3929,6 @@ void writeTypeEnum( std::ostream & os, EnumData const& enumData )
} }
os << " };" << std::endl; os << " };" << std::endl;
if (!enumData.alias.empty())
{
os << std::endl
<< " using " << enumData.alias << " = " << enumData.name << ";" << std::endl;
}
leaveProtect(os, enumData.protect); leaveProtect(os, enumData.protect);
os << std::endl; os << std::endl;
} }
@ -4440,12 +4522,6 @@ void writeTypeStruct( std::ostream & os, VkData const& vkData, DependencyData co
os << " };" << std::endl os << " };" << std::endl
<< " static_assert( sizeof( " << dependencyData.name << " ) == sizeof( Vk" << dependencyData.name << " ), \"struct and wrapper have different size!\" );" << 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); leaveProtect(os, it->second.protect);
os << std::endl; os << std::endl;
} }
@ -4461,13 +4537,17 @@ void writeStructureChainValidation(std::ostream & os, VkData const& vkData, Depe
// write out allowed structure chains // write out allowed structure chains
for (auto extendName : it->second.structExtends) for (auto extendName : it->second.structExtends)
{ {
std::map<std::string, StructData>::const_iterator itExtend = vkData.structs.find(extendName); // We do not have to generate the templates for aliased structs;
assert(itExtend != vkData.structs.end()); if (vkData.aliases.find(extendName) == vkData.aliases.end())
enterProtect(os, itExtend->second.protect); {
std::map<std::string, StructData>::const_iterator itExtend = vkData.structs.find(extendName);
assert(itExtend != vkData.structs.end());
enterProtect(os, itExtend->second.protect);
os << " template <> struct isStructureChainValid<" << extendName << ", " << dependencyData.name << ">{ enum { value = true }; };" << std::endl; os << " template <> struct isStructureChainValid<" << extendName << ", " << dependencyData.name << ">{ enum { value = true }; };" << std::endl;
leaveProtect(os, itExtend->second.protect); leaveProtect(os, itExtend->second.protect);
}
} }
leaveProtect(os, it->second.protect); leaveProtect(os, it->second.protect);
} }
@ -4589,6 +4669,9 @@ void writeTypes(std::ostream & os, VkData const& vkData, std::map<std::string, s
{ {
switch( it->category ) switch( it->category )
{ {
case DependencyData::Category::ALIAS:
writeTypeAlias(os, vkData, *it);
break;
case DependencyData::Category::COMMAND : case DependencyData::Category::COMMAND :
writeTypeCommand( os, vkData, *it ); writeTypeCommand( os, vkData, *it );
break; break;
@ -4654,7 +4737,7 @@ int main( int argc, char **argv )
tinyxml2::XMLError error = doc.LoadFile(filename.c_str()); tinyxml2::XMLError error = doc.LoadFile(filename.c_str());
if (error != tinyxml2::XML_SUCCESS) if (error != tinyxml2::XML_SUCCESS)
{ {
std::cout << "VkGenerate: failed to load file " << argv[1] << " . Error code: " << error << std::endl; std::cout << "VkGenerate: failed to load file " << filename << " . Error code: " << error << std::endl;
return -1; return -1;
} }
@ -4836,10 +4919,17 @@ int main( int argc, char **argv )
} }
#if !defined(NDEBUG) #if !defined(NDEBUG)
void skipTypeEnum(tinyxml2::XMLElement * element, std::map<std::string, std::string> const& attributes)
{
assert((attributes.find("category") != attributes.end()) && (attributes.find("category")->second == "enum"));
assert((attributes.size() == 1) || ((attributes.size() == 2) && (attributes.find("name") != attributes.end())));
assert(!element->FirstChildElement());
}
void skipTypeInclude(tinyxml2::XMLElement * element, std::map<std::string, std::string> const& attributes) void skipTypeInclude(tinyxml2::XMLElement * element, std::map<std::string, std::string> const& attributes)
{ {
assert((attributes.find("category") != attributes.end()) && (attributes.find("category")->second == "include")); assert((attributes.find("category") != attributes.end()) && (attributes.find("category")->second == "include"));
assert((attributes.size() == 1) || (attributes.find("name") != attributes.end())); assert((attributes.size() == 1) || ((attributes.size() == 2) && (attributes.find("name") != attributes.end())));
auto child = element->FirstChildElement(); auto child = element->FirstChildElement();
assert(!child || !child->NextSiblingElement()); assert(!child || !child->NextSiblingElement());

231
vulkan/vulkan.hpp
View File

@ -33,7 +33,7 @@
# include <memory> # include <memory>
# include <vector> # include <vector>
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
static_assert( VK_HEADER_VERSION == 65 , "Wrong VK_HEADER_VERSION!" ); static_assert( VK_HEADER_VERSION == 66 , "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // 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 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@ -7025,7 +7025,10 @@ namespace VULKAN_HPP_NAMESPACE
eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR,
eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, 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 eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT
}; };
struct ApplicationInfo struct ApplicationInfo
@ -14127,6 +14130,120 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
struct MemoryHostPointerPropertiesEXT
{
MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 )
: sType( StructureType::eMemoryHostPointerPropertiesEXT )
, pNext( nullptr )
, memoryTypeBits( memoryTypeBits_ )
{
}
MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
}
MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
return *this;
}
MemoryHostPointerPropertiesEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
MemoryHostPointerPropertiesEXT& setMemoryTypeBits( uint32_t memoryTypeBits_ )
{
memoryTypeBits = memoryTypeBits_;
return *this;
}
operator const VkMemoryHostPointerPropertiesEXT&() const
{
return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(this);
}
bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( memoryTypeBits == rhs.memoryTypeBits );
}
bool operator!=( MemoryHostPointerPropertiesEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType;
public:
void* pNext;
uint32_t memoryTypeBits;
};
static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
struct PhysicalDeviceExternalMemoryHostPropertiesEXT
{
PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 )
: sType( StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT )
, pNext( nullptr )
, minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
{
}
PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
}
PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
return *this;
}
PhysicalDeviceExternalMemoryHostPropertiesEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
PhysicalDeviceExternalMemoryHostPropertiesEXT& setMinImportedHostPointerAlignment( DeviceSize minImportedHostPointerAlignment_ )
{
minImportedHostPointerAlignment = minImportedHostPointerAlignment_;
return *this;
}
operator const VkPhysicalDeviceExternalMemoryHostPropertiesEXT&() const
{
return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
}
bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment );
}
bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType;
public:
void* pNext;
DeviceSize minImportedHostPointerAlignment;
};
static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
enum class SubpassContents enum class SubpassContents
{ {
eInline = VK_SUBPASS_CONTENTS_INLINE, eInline = VK_SUBPASS_CONTENTS_INLINE,
@ -22709,7 +22826,10 @@ namespace VULKAN_HPP_NAMESPACE
eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR,
eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR, eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR,
eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR,
eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR,
eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
}; };
using ExternalMemoryHandleTypeFlagsKHR = Flags<ExternalMemoryHandleTypeFlagBitsKHR, VkExternalMemoryHandleTypeFlagsKHR>; using ExternalMemoryHandleTypeFlagsKHR = Flags<ExternalMemoryHandleTypeFlagBitsKHR, VkExternalMemoryHandleTypeFlagsKHR>;
@ -22728,7 +22848,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
enum enum
{ {
allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT)
}; };
}; };
@ -23312,6 +23432,72 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
struct ImportMemoryHostPointerInfoEXT
{
ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, void* pHostPointer_ = nullptr )
: sType( StructureType::eImportMemoryHostPointerInfoEXT )
, pNext( nullptr )
, handleType( handleType_ )
, pHostPointer( pHostPointer_ )
{
}
ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
{
memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
}
ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
{
memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
return *this;
}
ImportMemoryHostPointerInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
ImportMemoryHostPointerInfoEXT& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ )
{
handleType = handleType_;
return *this;
}
ImportMemoryHostPointerInfoEXT& setPHostPointer( void* pHostPointer_ )
{
pHostPointer = pHostPointer_;
return *this;
}
operator const VkImportMemoryHostPointerInfoEXT&() const
{
return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(this);
}
bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( handleType == rhs.handleType )
&& ( pHostPointer == rhs.pHostPointer );
}
bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType;
public:
const void* pNext;
ExternalMemoryHandleTypeFlagBitsKHR handleType;
void* pHostPointer;
};
static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
enum class ExternalMemoryFeatureFlagBitsKHR enum class ExternalMemoryFeatureFlagBitsKHR
{ {
eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR, eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR,
@ -26472,10 +26658,10 @@ namespace VULKAN_HPP_NAMESPACE
enum class QueueGlobalPriorityEXT enum class QueueGlobalPriorityEXT
{ {
eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW, eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH, eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
}; };
struct DeviceQueueGlobalPriorityCreateInfoEXT struct DeviceQueueGlobalPriorityCreateInfoEXT
@ -28510,6 +28696,11 @@ namespace VULKAN_HPP_NAMESPACE
typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType ) const; typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
@ -31054,6 +31245,19 @@ namespace VULKAN_HPP_NAMESPACE
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const
{
return static_cast<Result>( vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( pMemoryHostPointerProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
VULKAN_HPP_INLINE ResultValueType<MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer ) const
{
MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
Result result = static_cast<Result>( vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( &memoryHostPointerProperties ) ) );
return createResultValue( result, memoryHostPointerProperties, "VULKAN_HPP_NAMESPACE::Device::getMemoryHostPointerPropertiesEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_NO_SMART_HANDLE #ifndef VULKAN_HPP_NO_SMART_HANDLE
class DeviceDeleter; class DeviceDeleter;
template <> class UniqueHandleTraits<Device> {public: using deleter = DeviceDeleter; }; template <> class UniqueHandleTraits<Device> {public: using deleter = DeviceDeleter; };
@ -33167,6 +33371,7 @@ namespace VULKAN_HPP_NAMESPACE
template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfoKHR>{ enum { value = true }; };
@ -33192,6 +33397,7 @@ namespace VULKAN_HPP_NAMESPACE
template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
#endif /*VK_USE_PLATFORM_WIN32_KHR*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/
template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryFdInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryFdInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryHostPointerInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageFormatProperties2KHR, ExternalImageFormatPropertiesKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<ImageFormatProperties2KHR, ExternalImageFormatPropertiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreCreateInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceCreateInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceCreateInfoKHR>{ enum { value = true }; };
@ -34594,6 +34800,9 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT"; case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT";
case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT"; case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT";
case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT"; case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT";
case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT";
case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT";
case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
default: return "invalid"; default: return "invalid";
} }
} }
@ -35809,6 +36018,9 @@ namespace VULKAN_HPP_NAMESPACE
case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt: return "D3D11TextureKmt"; case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt: return "D3D11TextureKmt";
case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap: return "D3D12Heap"; case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap: return "D3D12Heap";
case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource: return "D3D12Resource"; case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource: return "D3D12Resource";
case ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT: return "DmaBufEXT";
case ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT: return "HostAllocationEXT";
case ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT";
default: return "invalid"; default: return "invalid";
} }
} }
@ -35824,6 +36036,9 @@ namespace VULKAN_HPP_NAMESPACE
if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) result += "D3D11TextureKmt | "; if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) result += "D3D11TextureKmt | ";
if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) result += "D3D12Heap | "; if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) result += "D3D12Heap | ";
if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) result += "D3D12Resource | "; if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) result += "D3D12Resource | ";
if (value & ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT) result += "DmaBufEXT | ";
if (value & ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT) result += "HostAllocationEXT | ";
if (value & ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT) result += "HostMappedForeignMemoryEXT | ";
return "{" + result.substr(0, result.size() - 3) + "}"; return "{" + result.substr(0, result.size() - 3) + "}";
} }