From 8f21dfa0f51da33a8222abcb069ebbbff1607bef Mon Sep 17 00:00:00 2001 From: Markus Tavenrath Date: Tue, 16 May 2017 15:32:14 +0200 Subject: [PATCH] Use string templates in more places (#106) --- VulkanHppGenerator.cpp | 858 ++++++++++---------- vulkan/vulkan.hpp | 1709 +++++++++++++++++++--------------------- 2 files changed, 1236 insertions(+), 1331 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 1f756b7..1ec38d4 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -25,8 +25,8 @@ #include #include #include -#include -#include +#include +#include #include @@ -602,37 +602,37 @@ const std::string uniqueHandleHeader = R"( )"; -std::string replaceWithMap(std::string const &input, std::map replacements) -{ - // This will match ${someVariable} and contain someVariable in match group 1 - std::regex re(R"(\$\{([^\}]+)\})"); - auto it = std::sregex_iterator(input.begin(), input.end(), re); - auto end = std::sregex_iterator(); - - // No match, just return the original string - if (it == end) - { - return input; - } - - std::string result = ""; - while (it != end) - { - std::smatch match = *it; - auto itReplacement = replacements.find(match[1].str()); - assert(itReplacement != replacements.end()); - - result += match.prefix().str() + ((itReplacement != replacements.end()) ? itReplacement->second : match[0].str()); - ++it; - - // we've passed the last match. Append the rest of the orignal string - if (it == end) - { - result += match.suffix().str(); - } - } - return result; -} +std::string replaceWithMap(std::string const &input, std::map replacements) +{ + // This will match ${someVariable} and contain someVariable in match group 1 + std::regex re(R"(\$\{([^\}]+)\})"); + auto it = std::sregex_iterator(input.begin(), input.end(), re); + auto end = std::sregex_iterator(); + + // No match, just return the original string + if (it == end) + { + return input; + } + + std::string result = ""; + while (it != end) + { + std::smatch match = *it; + auto itReplacement = replacements.find(match[1].str()); + assert(itReplacement != replacements.end()); + + result += match.prefix().str() + ((itReplacement != replacements.end()) ? itReplacement->second : match[0].str()); + ++it; + + // we've passed the last match. Append the rest of the orignal string + if (it == end) + { + result += match.suffix().str(); + } + } + return result; +} struct ParamData { @@ -837,10 +837,10 @@ 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::ofstream & ofs, std::pair> const& deleterTypes, std::map const& deleterData); -void writeDeleterForwardDeclarations(std::ofstream &ofs, std::pair> const& deleterTypes, std::map const& deleterData); -void writeEnumsToString(std::ofstream & ofs, EnumData const& enumData); -void writeFlagsToString(std::ofstream & ofs, std::string const& flagsName, EnumData const &enumData); +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 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); void writeFunctionBodyEnhanced(std::ostream & os, std::string const& indentation, VkData const& vkData, CommandData const& commandData, bool singular); void writeFunctionBodyEnhancedCall(std::ostream &os, std::string const& indentation, std::set const& vkTypes, CommandData const& commandData, bool singular); @@ -861,24 +861,24 @@ void writeFunctionHeaderName(std::ostream & os, std::string const& name, bool si void writeFunctionHeaderReturnType(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool enhanced, bool singular, bool unique); void writeFunctionHeaderTemplate(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool withDefault); void writeReinterpretCast(std::ostream & os, bool leadingConst, bool vulkanType, std::string const& type, bool trailingPointerToConst); -void writeStandardOrEnhanced(std::ofstream & ofs, std::string const& standard, std::string const& enhanced); -void writeStructConstructor( std::ofstream & ofs, std::string const& name, StructData const& structData, std::set const& vkTypes, std::map const& defaultValues ); -void writeStructSetter( std::ofstream & ofs, std::string const& structureName, MemberData const& memberData, std::set const& vkTypes, std::map const& structs ); -void writeTypeCommand(std::ofstream & ofs, VkData const& vkData, DependencyData const& dependencyData); -void writeTypeCommand(std::ofstream &ofs, std::string const& indentation, VkData const& vkData, CommandData const& commandData, bool definition); -void writeTypeEnum(std::ofstream & ofs, EnumData const& enumData); +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 const& vkTypes, std::map const& defaultValues ); +void writeStructSetter( std::ostream & os, std::string const& structureName, MemberData const& memberData, std::set const& vkTypes, std::map const& structs ); +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 writeTypeEnum(std::ostream & os, EnumData const& enumData); bool isErrorEnum(std::string const& enumName); std::string stripErrorEnumPrefix(std::string const& enumName); -void writeExceptionsForEnum(std::ofstream & ofs, EnumData const& enumData); -void writeThrowExceptions(std::ofstream& ofs, EnumData const& enumData); -void writeTypeFlags(std::ofstream & ofs, std::string const& flagsName, FlagData const& flagData, EnumData const& enumData); -void writeTypeHandle(std::ofstream & ofs, VkData const& vkData, DependencyData const& dependencyData, HandleData const& handle, std::list const& dependencies); -void writeTypeScalar( std::ofstream & ofs, DependencyData const& dependencyData ); -void writeTypeStruct( std::ofstream & ofs, VkData const& vkData, DependencyData const& dependencyData, std::map const& defaultValues ); -void writeTypeUnion( std::ofstream & ofs, VkData const& vkData, DependencyData const& dependencyData, std::map const& defaultValues ); -void writeTypes(std::ofstream & ofs, VkData const& vkData, std::map const& defaultValues); -void writeVersionCheck(std::ofstream & ofs, std::string const& version); -void writeTypesafeCheck(std::ofstream & ofs, std::string const& typesafeCheck); +void writeExceptionsForEnum(std::ostream & os, EnumData const& enumData); +void writeThrowExceptions(std::ostream& os, EnumData const& enumData); +void writeTypeFlags(std::ostream & os, std::string const& flagsName, FlagData const& flagData, EnumData const& enumData); +void writeTypeHandle(std::ostream & os, VkData const& vkData, DependencyData const& dependencyData, HandleData const& handle, std::list const& dependencies); +void writeTypeScalar( std::ostream & os, DependencyData const& dependencyData ); +void writeTypeStruct( std::ostream & os, VkData const& vkData, DependencyData const& dependencyData, std::map const& defaultValues ); +void writeTypeUnion( std::ostream & os, VkData const& vkData, DependencyData const& dependencyData, std::map const& defaultValues ); +void writeTypes(std::ostream & os, VkData const& vkData, std::map const& defaultValues); +void writeVersionCheck(std::ostream & os, std::string const& version); +void writeTypesafeCheck(std::ostream & os, std::string const& typesafeCheck); void EnumData::addEnumMember(std::string const &name, std::string const& tag) { @@ -1207,7 +1207,7 @@ std::string readArraySize(tinyxml2::XMLNode * node, std::string& name) } else { - // otherwise, the node holds '[' and ']', so get the stuff inbetween those as the array size + // otherwise, the node holds '[' and ']', so get the stuff in between those as the array size assert((value.front() == '[') && (value.back() == ']')); arraySize = value.substr(1, value.length() - 2); assert(!node->NextSibling()); @@ -2975,6 +2975,8 @@ void writeFunctionHeaderName(std::ostream & os, std::string const& name, bool si void writeFunctionHeaderReturnType(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool enhanced, bool singular, bool unique) { + std::string templateString; + std::string returnType; if (enhanced) { // the enhanced function might return some pretty complex return stuff @@ -2983,16 +2985,9 @@ void writeFunctionHeaderReturnType(std::ostream & os, std::string const& indenta // the unique version returns something prefixed with 'Unique'; potentially a vector of that stuff // it's a vector, if it's not the singular version and the return parameter is a vector parameter bool returnsVector = !singular && (commandData.vectorParams.find(commandData.returnParam) != commandData.vectorParams.end()); - if (returnsVector) - { - os << "std::vector<"; - } - os << "Unique" << commandData.params[commandData.returnParam].pureType; - if (returnsVector) - { - os << ">"; - } - os << " "; + templateString = returnsVector ? "std::vector " : "Unique${returnType} "; + returnType = commandData.params[commandData.returnParam].pureType; + //os << replaceWithMap(, {{"returnType", commandData.params[commandData.returnParam].pureType }}); } else if ((commandData.enhancedReturnType != commandData.returnType) && (commandData.returnType != "void")) { @@ -3000,29 +2995,37 @@ void writeFunctionHeaderReturnType(std::ostream & os, std::string const& indenta if (!singular && (commandData.enhancedReturnType.find("Allocator") != std::string::npos)) { // for the non-singular case with allocation, we need to prepend with 'typename' to keep compilers happy - os << "typename "; + templateString = "typename ResultValueType<${returnType}>::type "; + } + else + { + templateString = "ResultValueType<${returnType}>::type "; } assert(commandData.returnType == "Result"); // in singular case, we create the ResultValueType from the pure return type, otherwise from the enhanced return type - os << "ResultValueType<" << (singular ? commandData.params[commandData.returnParam].pureType : commandData.enhancedReturnType) << ">::type "; + returnType = singular ? commandData.params[commandData.returnParam].pureType : commandData.enhancedReturnType; } else if ((commandData.returnParam != ~0) && (1 < commandData.successCodes.size())) { // if there is a return parameter at all, and there are multiple success codes, we return a ResultValue<...> with the pure return type assert(commandData.returnType == "Result"); - os << "ResultValue<" << commandData.params[commandData.returnParam].pureType << "> "; + templateString = "ResultValue<${returnType}> "; + returnType = commandData.params[commandData.returnParam].pureType; } else { // and in every other case, we just return the enhanced return type. - os << commandData.enhancedReturnType << " "; + templateString = "${returnType} "; + returnType = commandData.enhancedReturnType; } } else { // the non-enhanced function just uses the return type - os << commandData.returnType << " "; + templateString = "${returnType} "; + returnType = commandData.returnType; } + os << replaceWithMap(templateString, { { "returnType", returnType } }); } void writeFunctionHeaderTemplate(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool withDefault) @@ -3066,12 +3069,12 @@ void writeReinterpretCast(std::ostream & os, bool leadingConst, bool vulkanType, os << "*>"; } -void writeStandardOrEnhanced(std::ofstream & ofs, std::string const& standard, std::string const& enhanced) +void writeStandardOrEnhanced(std::ostream & os, std::string const& standard, std::string const& enhanced) { if (standard == enhanced) { // standard and enhanced string are equal -> just use one of them and we're done - ofs << standard; + os << standard; } else { @@ -3084,25 +3087,25 @@ void writeStandardOrEnhanced(std::ofstream & ofs, std::string const& standard, s bool unchangedInterface = (standard.substr(standardStart, standardCount) == enhanced.substr(enhancedStart, standardCount)); if (unchangedInterface) { - ofs << "#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE" << std::endl; + os << "#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE" << std::endl; } - ofs << standard + os << standard << (unchangedInterface ? "#else" : "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE") << std::endl << enhanced << "#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/" << std::endl; } } -void writeStructConstructor( std::ofstream & ofs, std::string const& name, StructData const& structData, std::set const& vkTypes, std::map const& defaultValues ) +void writeStructConstructor( std::ostream & os, std::string const& name, StructData const& structData, std::set const& vkTypes, std::map const& defaultValues ) { // the constructor with all the elements as arguments, with defaults - ofs << " " << name << "( "; + os << " " << name << "( "; bool listedArgument = false; for (size_t i = 0; isecond); + os << structData.members[i].type << " " << structData.members[i].name << "_ = " << (structData.members[i].type.back() == '*' ? "nullptr" : defaultIt->second); } else { // array members are provided as const reference to a std::array // the arguments name get a trailing '_', to distinguish them from the actual struct members // list as many default values as there are elements in the array - ofs << "std::array<" << structData.members[i].type << "," << structData.members[i].arraySize << "> const& " << structData.members[i].name << "_ = { { " << defaultIt->second; + os << "std::array<" << structData.members[i].type << "," << structData.members[i].arraySize << "> const& " << structData.members[i].name << "_ = { { " << defaultIt->second; size_t n = atoi(structData.members[i].arraySize.c_str()); assert(0 < n); for (size_t j = 1; j < n; j++) { - ofs << ", " << defaultIt->second; + os << ", " << defaultIt->second; } - ofs << " } }"; + os << " } }"; } listedArgument = true; } } - ofs << " )" << std::endl; + os << " )" << std::endl; // copy over the simple arguments bool firstArgument = true; @@ -3143,91 +3146,98 @@ void writeStructConstructor( std::ofstream & ofs, std::string const& name, Struc if (structData.members[i].arraySize.empty()) { // here, we can only handle non-array arguments - ofs << " " << (firstArgument ? ":" : ",") << " " << structData.members[i].name << "( "; + std::string templateString = " ${sep} ${member}( ${value} )\n"; + std::string sep = firstArgument ? ":" : ","; + std::string member = structData.members[i].name; + std::string value; // 'pNext' and 'sType' don't get an argument, use nullptr and the correct StructureType enum value to initialize them if (structData.members[i].name == "pNext") { - ofs << "nullptr"; + value = "nullptr"; } else if (structData.members[i].name == "sType") { - ofs << "StructureType::e" << name; + value = std::string("StructureType::e") + name; } else { // the other elements are initialized by the corresponding argument (with trailing '_', as mentioned above) - ofs << structData.members[i].name << "_"; + value = structData.members[i].name + "_"; } - ofs << " )" << std::endl; + os << replaceWithMap(templateString, { {"sep", sep}, {"member", member}, {"value", value} }); firstArgument = false; } } // the body of the constructor, copying over data from argument list into wrapped struct - ofs << " {" << std::endl; + os << " {" << std::endl; for ( size_t i=0 ; i const& vkTypes ) +void writeStructSetter( std::ostream & os, std::string const& structureName, MemberData const& memberData, std::set const& vkTypes ) { if (memberData.type != "StructureType") // filter out StructureType, which is supposed to be immutable ! { // the setters return a reference to the structure - ofs << " " << structureName << "& set" << startUpperCase(memberData.name) << "( "; + os << " " << structureName << "& set" << startUpperCase(memberData.name) << "( "; if (memberData.arraySize.empty()) { - ofs << memberData.type << " "; + os << memberData.type << " "; } else { - ofs << "std::array<" << memberData.type << "," << memberData.arraySize << "> "; + os << "std::array<" << memberData.type << "," << memberData.arraySize << "> "; } // add a trailing '_' to the argument to distinguish it from the structure member - ofs << memberData.name << "_ )" << std::endl + os << memberData.name << "_ )" << std::endl << " {" << std::endl; // copy over the argument, either by assigning simple data, or by memcpy array data if (memberData.arraySize.empty()) { - ofs << " " << memberData.name << " = " << memberData.name << "_"; + os << " " << memberData.name << " = " << memberData.name << "_"; } else { - ofs << " memcpy( &" << memberData.name << ", " << memberData.name << "_.data(), " << memberData.arraySize << " * sizeof( " << memberData.type << " ) )"; + os << " memcpy( &" << memberData.name << ", " << memberData.name << "_.data(), " << memberData.arraySize << " * sizeof( " << memberData.type << " ) )"; } - ofs << ";" << std::endl + os << ";" << std::endl << " return *this;" << std::endl << " }" << std::endl << std::endl; } } -void writeTypeCommand(std::ofstream & ofs, 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()); CommandData const& commandData = vkData.commands.find(dependencyData.name)->second; @@ -3239,22 +3249,22 @@ void writeTypeCommand(std::ofstream & ofs, VkData const& vkData, DependencyData auto deleterTypesIt = vkData.deleterTypes.find(""); assert((deleterTypesIt != vkData.deleterTypes.end()) && (deleterTypesIt->second.size() == 1)); - writeDeleterForwardDeclarations(ofs, *deleterTypesIt, vkData.deleterData); - writeTypeCommand(ofs, " ", vkData, commandData, false); - writeDeleterClasses(ofs, *deleterTypesIt, vkData.deleterData); + writeDeleterForwardDeclarations(os, *deleterTypesIt, vkData.deleterData); + writeTypeCommand(os, " ", vkData, commandData, false); + writeDeleterClasses(os, *deleterTypesIt, vkData.deleterData); } else { - writeTypeCommand(ofs, " ", vkData, commandData, false); + writeTypeCommand(os, " ", vkData, commandData, false); } - writeTypeCommand(ofs, " ", vkData, commandData, true); - ofs << std::endl; + writeTypeCommand(os, " ", vkData, commandData, true); + os << std::endl; } } -void writeTypeCommand(std::ofstream & ofs, 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) { - enterProtect(ofs, commandData.protect); + enterProtect(os, commandData.protect); // first create the standard version of the function std::ostringstream standard; @@ -3289,29 +3299,29 @@ void writeTypeCommand(std::ofstream & ofs, std::string const& indentation, VkDat } // and write one or both of them - writeStandardOrEnhanced(ofs, standard.str(), enhanced.str()); - leaveProtect(ofs, commandData.protect); - ofs << std::endl; + writeStandardOrEnhanced(os, standard.str(), enhanced.str()); + leaveProtect(os, commandData.protect); + os << std::endl; } -void writeTypeEnum( std::ofstream & ofs, EnumData const& enumData ) +void writeTypeEnum( std::ostream & os, EnumData const& enumData ) { // a named enum per enum, listing all its values by setting them to the original Vulkan names - enterProtect(ofs, enumData.protect); - ofs << " enum class " << enumData.name << std::endl + enterProtect(os, enumData.protect); + os << " enum class " << enumData.name << std::endl << " {" << std::endl; for ( size_t i=0 ; i(result) < 0 );" << std::endl - << " switch ( result )" << std::endl - << " {" << std::endl; + enterProtect(os, enumData.protect); + os << +R"( VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) + { + assert ( static_cast(result) < 0 ); + switch ( result ) + { +)"; for ( size_t i=0 ; i> const& deleterTypes, std::map const& deleterData) +void writeDeleterClasses(std::ostream & os, std::pair> const& deleterTypes, std::map const& deleterData) { // A Deleter class for each of the Unique* classes... but only if smart handles are not switched off - ofs << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl; + os << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl; bool first = true; // get type and name of the parent (holder) type @@ -3393,18 +3413,18 @@ void writeDeleterClasses(std::ofstream & ofs, std::pairsecond.pool.empty() ? "" : startLowerCase(dd->second.pool)); if (poolName.empty()) { - ofs << "Optional allocator = nullptr )" << std::endl; + os << "Optional allocator = nullptr )" << std::endl; } else { assert(!dd->second.pool.empty()); - ofs << dd->second.pool << " " << poolName << " = " << dd->second.pool << "() )" << std::endl; + os << dd->second.pool << " " << poolName << " = " << dd->second.pool << "() )" << std::endl; } // now the initializer list of the Deleter constructor - ofs << " : "; + os << " : "; if (standardDeleter) { // the standard deleter has a parent type as a member - ofs << "m_" << parentName << "( " << parentName << " )" << std::endl + os << "m_" << parentName << "( " << parentName << " )" << std::endl << " , "; } if (poolName.empty()) { // non-pooled deleter have an allocator as a member - ofs << "m_allocator( allocator )" << std::endl; + os << "m_allocator( allocator )" << std::endl; } else { // pooled deleter have a pool as a member - ofs << "m_" << poolName << "( " << poolName << " )" << std::endl; + os << "m_" << poolName << "( " << poolName << " )" << std::endl; } // besides that, the constructor is empty - ofs << " {}" << std::endl + os << " {}" << std::endl << std::endl; // the operator() calls the delete/destroy function - ofs << " void operator()( " << deleterType << " " << deleterName << " )" << std::endl + os << " void operator()( " << deleterType << " " << deleterName << " )" << std::endl << " {" << std::endl; // the delete/destroy function is either part of the parent member of the deleter argument if (standardDeleter) { - ofs << " m_" << parentName << "."; + os << " m_" << parentName << "."; } else { - ofs << " " << deleterName << "."; + os << " " << deleterName << "."; } - ofs << dd->second.call << "( "; + os << dd->second.call << "( "; if (!poolName.empty()) { // pooled Deleter gets the pool as the first argument - ofs << "m_" << poolName << ", "; + os << "m_" << poolName << ", "; } if (standardDeleter) { // the standard deleter gets the deleter argument as an argument - ofs << deleterName; + os << deleterName; } // the non-pooled deleter get the allocate as an argument (potentially after the deleterName @@ -3477,271 +3497,268 @@ void writeDeleterClasses(std::ofstream & ofs, std::pair m_allocator;" << std::endl; + os << " Optional m_allocator;" << std::endl; } else { - ofs << " " << dd->second.pool << " m_" << poolName << ";" << std::endl; + os << " " << dd->second.pool << " m_" << poolName << ";" << std::endl; } - ofs << " };" << std::endl; + os << " };" << std::endl; } - ofs << "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/" << std::endl + os << "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/" << std::endl << std::endl; } -void writeDeleterForwardDeclarations(std::ofstream &ofs, std::pair> const& deleterTypes, std::map const& deleterData) +void writeDeleterForwardDeclarations(std::ostream &os, std::pair> const& deleterTypes, std::map const& deleterData) { // if smart handles are supported, all the Deleter classes need to be forward declared - ofs << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl; + os << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl; bool first = true; std::string firstName = deleterTypes.first.empty() ? "" : startLowerCase(deleterTypes.first); for (auto const& dt : deleterTypes.second) { - ofs << " class " << dt << "Deleter;" << std::endl; - ofs << " using Unique" << dt << " = UniqueHandle<" << dt << ", " << dt << "Deleter>;" << std::endl; + os << " class " << dt << "Deleter;" << std::endl; + os << " using Unique" << dt << " = UniqueHandle<" << dt << ", " << dt << "Deleter>;" << std::endl; } - ofs << "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/" << std::endl + os << "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/" << std::endl << std::endl; } -void writeEnumsToString(std::ofstream & ofs, EnumData const& enumData) +void writeEnumsToString(std::ostream & os, EnumData const& enumData) { // the helper functions to make strings out of enum values - enterProtect(ofs, enumData.protect); - ofs << " VULKAN_HPP_INLINE std::string to_string(" << enumData.name << (enumData.members.empty() ? ")" : " value)") << std::endl + enterProtect(os, enumData.protect); + os << " VULKAN_HPP_INLINE std::string to_string(" << enumData.name << (enumData.members.empty() ? ")" : " value)") << std::endl << " {" << std::endl; if (enumData.members.empty()) { // no enum values in this enum -> return "(void)" - ofs << " return \"(void)\";" << std::endl; + os << " return \"(void)\";" << std::endl; } else { // otherwise switch over the value and return the a stringized version of that value (without leading 'e') - ofs << " switch (value)" << std::endl + os << " switch (value)" << std::endl << " {" << std::endl; for (auto const& member : enumData.members) { - ofs << " case " << enumData.name << "::" << member.name << ": return \"" << member.name.substr(1) << "\";" << std::endl; + os << " case " << enumData.name << "::" << member.name << ": return \"" << member.name.substr(1) << "\";" << std::endl; } - ofs << " default: return \"invalid\";" << std::endl + os << " default: return \"invalid\";" << std::endl << " }" << std::endl; } - ofs << " }" << std::endl; - leaveProtect(ofs, enumData.protect); - ofs << std::endl; + os << " }" << std::endl; + leaveProtect(os, enumData.protect); + os << std::endl; } -void writeFlagsToString(std::ofstream & ofs, std::string const& flagsName, EnumData const &enumData) +void writeFlagsToString(std::ostream & os, std::string const& flagsName, EnumData const &enumData) { // the helper functions to make strings out of flag values - enterProtect(ofs, enumData.protect); - ofs << " VULKAN_HPP_INLINE std::string to_string(" << flagsName << (enumData.members.empty() ? ")" : " value)") << std::endl + enterProtect(os, enumData.protect); + os << " VULKAN_HPP_INLINE std::string to_string(" << flagsName << (enumData.members.empty() ? ")" : " value)") << std::endl << " {" << std::endl; if (enumData.members.empty()) { // no flags values in this enum -> return "{}" - ofs << " return \"{}\";" << std::endl; + os << " return \"{}\";" << std::endl; } else { - ofs << " if (!value) return \"{}\";" << std::endl + os << " if (!value) return \"{}\";" << std::endl << " std::string result;" << std::endl; // 'or' together all the bits in the value for (auto itMember = enumData.members.begin(); itMember != enumData.members.end(); ++itMember) { - ofs << " if (value & " << enumData.name << "::" << itMember->name << ") result += \"" << itMember->name.substr(1) << " | \";" << std::endl; + os << " if (value & " << enumData.name << "::" << itMember->name << ") result += \"" << itMember->name.substr(1) << " | \";" << std::endl; } // cut off the last three characters from the result (being " | ") - ofs << " return \"{\" + result.substr(0, result.size() - 3) + \"}\";" << std::endl; + os << " return \"{\" + result.substr(0, result.size() - 3) + \"}\";" << std::endl; } - ofs << " }" << std::endl; - leaveProtect(ofs, enumData.protect); - ofs << std::endl; + os << " }" << std::endl; + leaveProtect(os, enumData.protect); + os << std::endl; } -void writeTypeFlags(std::ofstream & ofs, std::string const& flagsName, FlagData const& flagData, EnumData const& enumData) +void writeTypeFlags(std::ostream & os, std::string const& flagsName, FlagData const& flagData, EnumData const& enumData) { - enterProtect(ofs, flagData.protect); + enterProtect(os, flagData.protect); // each Flags class is using on the class 'Flags' with the corresponding FlagBits enum as the template parameter - ofs << " using " << flagsName << " = Flags<" << enumData.name << ", Vk" << flagsName << ">;" << std::endl; + os << " using " << flagsName << " = Flags<" << enumData.name << ", Vk" << flagsName << ">;" << std::endl; + + std::stringstream allFlags; + for (size_t i = 0; i < enumData.members.size(); i++) + { + if (i != 0) + { + allFlags << " | "; + } + allFlags << "VkFlags(" << enumData.name << "::" << enumData.members[i].name << ")"; + } if (!enumData.members.empty()) { - ofs << std::endl; - - // the operator| of two FlagBits into one Flags is mapped to the operator| of the Flags class - ofs << " VULKAN_HPP_INLINE " << flagsName << " operator|( " << enumData.name << " bit0, " << enumData.name << " bit1 )" << std::endl - << " {" << std::endl - << " return " << flagsName << "( bit0 ) | bit1;" << std::endl - << " }" << std::endl - << std::endl; - - // the operator~ on a FlagBits is mapped to the operator~ of the Flags class - ofs << " VULKAN_HPP_INLINE " << flagsName << " operator~( " << enumData.name << " bits )" << std::endl - << " {" << std::endl - << " return ~( " << flagsName << "( bits ) );" << std::endl - << " }" << std::endl - << std::endl; - - // the FlagTraits on FlagBits hold a value allFlags with all the defined bits set - ofs << " template <> struct FlagTraits<" << enumData.name << ">" << std::endl - << " {" << std::endl - << " enum" << std::endl - << " {" << std::endl - << " allFlags = "; - for (size_t i = 0; i < enumData.members.size(); i++) - { - if (i != 0) - { - ofs << " | "; - } - ofs << "VkFlags(" << enumData.name << "::" << enumData.members[i].name << ")"; - } - ofs << std::endl - << " };" << std::endl - << " };" << std::endl; + const std::string templateString = R"( + VULKAN_HPP_INLINE ${flagsName} operator|( ${enumName} bit0, ${enumName} bit1 ) + { + return ${flagsName}( bit0 ) | bit1; } - leaveProtect(ofs, flagData.protect); - ofs << std::endl; + + VULKAN_HPP_INLINE ${flagsName} operator~( ${enumName} bits ) + { + return ~( ${flagsName}( bits ) ); + } + + template <> struct FlagTraits<${enumName}> + { + enum + { + allFlags = ${allFlags} + }; + }; +)"; + os << replaceWithMap(templateString, { { "flagsName", flagsName}, { "enumName", enumData.name }, { "allFlags", allFlags.str() } } ); + } + leaveProtect(os, flagData.protect); + os << std::endl; } -void writeTypeHandle(std::ofstream & ofs, VkData const& vkData, DependencyData const& dependencyData, HandleData const& handleData, std::list const& dependencies) +void writeTypeHandle(std::ostream & os, VkData const& vkData, DependencyData const& dependencyData, HandleData const& handleData, std::list const& dependencies) { - enterProtect(ofs, handleData.protect); + enterProtect(os, handleData.protect); // check if there are any forward dependenices for this handle -> list them first if (!dependencyData.forwardDependencies.empty()) { - ofs << " // forward declarations" << std::endl; + os << " // forward declarations" << std::endl; for (std::set::const_iterator it = dependencyData.forwardDependencies.begin(); it != dependencyData.forwardDependencies.end(); ++it) { assert(vkData.structs.find(*it) != vkData.structs.end()); - ofs << " struct " << *it << ";" << std::endl; + os << " struct " << *it << ";" << std::endl; } - ofs << std::endl; + os << std::endl; } // then write any forward declaration of Deleters used by this handle std::map>::const_iterator deleterTypesIt = vkData.deleterTypes.find(dependencyData.name); if (deleterTypesIt != vkData.deleterTypes.end()) { - writeDeleterForwardDeclarations(ofs, *deleterTypesIt, vkData.deleterData); + writeDeleterForwardDeclarations(os, *deleterTypesIt, vkData.deleterData); } - std::string memberName = startLowerCase(dependencyData.name); - ofs << " class " << dependencyData.name << std::endl - << " {" << std::endl - << " public:" << std::endl - << " " << dependencyData.name << "()" << std::endl - << " : m_" << memberName << "(VK_NULL_HANDLE)" << std::endl - << " {}" << std::endl - << std::endl - << " " << dependencyData.name << "( std::nullptr_t )" << std::endl - << " : m_" << memberName << "(VK_NULL_HANDLE)" << std::endl - << " {}" << std::endl - << std::endl - // construct from native handle - << " VULKAN_HPP_TYPESAFE_EXPLICIT " << dependencyData.name << "(Vk" << dependencyData.name << " " << memberName << ")" << std::endl - << " : m_" << memberName << "(" << memberName << ")" << std::endl - << " {}" << std::endl - << std::endl - // assignment from native handle - << "#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)" << std::endl - << " " << dependencyData.name << "& operator=(Vk" << dependencyData.name << " " << memberName << ")" << std::endl - << " {" << std::endl - << " m_" << memberName << " = " << memberName << ";" << std::endl - << " return *this;" << std::endl - << " }" << std::endl - << "#endif" << std::endl - << std::endl - // assignment from std::nullptr_t - << " " << dependencyData.name << "& operator=( std::nullptr_t )" << std::endl - << " {" << std::endl - << " m_" << memberName << " = VK_NULL_HANDLE;" << std::endl - << " return *this;" << std::endl - << " }" << std::endl - << std::endl - // operator== - << " bool operator==" << "(" << dependencyData.name << " const &rhs) const" << std::endl - << " {" << std::endl - << " return m_" << memberName << " == rhs.m_" << memberName << ";" << std::endl - << " }" << std::endl - << std::endl - // operator!= - << " bool operator!=" << "(" << dependencyData.name << " const &rhs) const" << std::endl - << " {" << std::endl - << " return m_" << memberName << " != rhs.m_" << memberName << ";" << std::endl - << " }" << std::endl - << std::endl - // operator< - << " bool operator<" << "(" << dependencyData.name << " const &rhs) const" << std::endl - << " {" << std::endl - << " return m_" << memberName << " < rhs.m_" << memberName << ";" << std::endl - << " }" << std::endl - << std::endl; + const std::string memberName = startLowerCase(dependencyData.name); + const std::string templateString = +R"( class ${className} + { + public: + ${className}() + : m_${memberName}(VK_NULL_HANDLE) + {} + ${className}( std::nullptr_t ) + : m_${memberName}(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ${className}( Vk${className} ${memberName} ) + : m_${memberName}( ${memberName} ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + ${className} & operator=(Vk${className} ${memberName}) + { + m_${memberName} = ${memberName}; + return *this; + } +#endif + + ${className} & operator=( std::nullptr_t ) + { + m_${memberName} = VK_NULL_HANDLE; + return *this; + } + + bool operator==( ${className} const & rhs ) const + { + return m_${memberName} == rhs.m_${memberName}; + } + + bool operator!=(${className} const & rhs ) const + { + return m_${memberName} != rhs.m_${memberName}; + } + + bool operator<(${className} const & rhs ) const + { + return m_${memberName} < rhs.m_${memberName}; + } + +${commands} + + VULKAN_HPP_TYPESAFE_EXPLICIT operator Vk${className}() const + { + return m_${memberName}; + } + + explicit operator bool() const + { + return m_${memberName} != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_${memberName} == VK_NULL_HANDLE; + } + + private: + Vk${className} m_${memberName}; + }; + + static_assert( sizeof( ${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" ); + +)"; + + std::ostringstream commands; // now list all the commands that are mapped to members of this class for (size_t i = 0; i < handleData.commands.size(); i++) { std::string commandName = handleData.commands[i]; std::map::const_iterator cit = vkData.commands.find(commandName); assert((cit != vkData.commands.end()) && !cit->second.className.empty()); - writeTypeCommand(ofs, " ", vkData, cit->second, false); + writeTypeCommand(commands, " ", vkData, cit->second, false); } - // finally list the cast operators to the corresponding Vk-type, and to bool (explicit), and the operator! - ofs << " VULKAN_HPP_TYPESAFE_EXPLICIT operator Vk" << dependencyData.name << "() const" << std::endl - << " {" << std::endl - << " return m_" << memberName << ";" << std::endl - << " }" << std::endl - << std::endl - << " explicit operator bool() const" << std::endl - << " {" << std::endl - << " return m_" << memberName << " != VK_NULL_HANDLE;" << std::endl - << " }" << std::endl - << std::endl - << " bool operator!() const" << std::endl - << " {" << std::endl - << " return m_" << memberName << " == VK_NULL_HANDLE;" << std::endl - << " }" << std::endl - << std::endl; + os << replaceWithMap(templateString, { + { "className", dependencyData.name }, + { "memberName", memberName }, + { "commands", commands.str() } + }); - // and last but not least: the member variable: a corresponding Vk-type - ofs << " private:" << std::endl - << " Vk" << dependencyData.name << " m_" << memberName << ";" << std::endl - << " };" << std::endl; - - // and a little safety check, that our class has the same size as the corresponding Vk-type - ofs << " static_assert( sizeof( " << dependencyData.name << " ) == sizeof( Vk" << dependencyData.name << " ), \"handle and wrapper have different size!\" );" << std::endl - << std::endl; - - // then the actual Deleter classes can be listet + // then the actual Deleter classes can be listed deleterTypesIt = vkData.deleterTypes.find(dependencyData.name); if (deleterTypesIt != vkData.deleterTypes.end()) { - writeDeleterClasses(ofs, *deleterTypesIt, vkData.deleterData); + writeDeleterClasses(os, *deleterTypesIt, vkData.deleterData); } // and finally the commands, that are member functions of this handle @@ -3752,16 +3769,16 @@ void writeTypeHandle(std::ofstream & ofs, VkData const& vkData, DependencyData c assert((cit != vkData.commands.end()) && !cit->second.className.empty()); std::list::const_iterator dep = std::find_if(dependencies.begin(), dependencies.end(), [commandName](DependencyData const& dd) { return dd.name == commandName; }); assert(dep != dependencies.end() && (dep->name == cit->second.fullName)); - writeTypeCommand(ofs, " ", vkData, cit->second, true); + writeTypeCommand(os, " ", vkData, cit->second, true); } - leaveProtect(ofs, handleData.protect); + leaveProtect(os, handleData.protect); } -void writeTypeScalar( std::ofstream & ofs, DependencyData const& dependencyData ) +void writeTypeScalar( std::ostream & os, DependencyData const& dependencyData ) { assert( dependencyData.dependencies.size() == 1 ); - ofs << " using " << dependencyData.name << " = " << *dependencyData.dependencies.begin() << ";" << std::endl + os << " using " << dependencyData.name << " = " << *dependencyData.dependencies.begin() << ";" << std::endl << std::endl; } @@ -3781,19 +3798,19 @@ bool containsUnion(std::string const& type, std::map co return found; } -void writeTypeStruct( std::ofstream & ofs, VkData const& vkData, DependencyData const& dependencyData, std::map const& defaultValues ) +void writeTypeStruct( std::ostream & os, VkData const& vkData, DependencyData const& dependencyData, std::map const& defaultValues ) { std::map::const_iterator it = vkData.structs.find( dependencyData.name ); assert( it != vkData.structs.end() ); - enterProtect(ofs, it->second.protect); - ofs << " struct " << dependencyData.name << std::endl + enterProtect(os, it->second.protect); + os << " struct " << dependencyData.name << std::endl << " {" << std::endl; // only structs that are not returnedOnly get a constructor! if ( !it->second.returnedOnly ) { - writeStructConstructor( ofs, dependencyData.name, it->second, vkData.vkTypes, defaultValues ); + writeStructConstructor( os, dependencyData.name, it->second, vkData.vkTypes, defaultValues ); } // create the setters @@ -3801,12 +3818,12 @@ void writeTypeStruct( std::ofstream & ofs, VkData const& vkData, DependencyData { for (size_t i = 0; isecond.members.size(); i++) { - writeStructSetter( ofs, dependencyData.name, it->second.members[i], vkData.vkTypes ); + writeStructSetter( os, dependencyData.name, it->second.members[i], vkData.vkTypes ); } } // the cast-operator to the wrapped struct - ofs << " operator const Vk" << dependencyData.name << "&() const" << std::endl + os << " operator const Vk" << dependencyData.name << "&() const" << std::endl << " {" << std::endl << " return *reinterpret_cast(this);" << std::endl << " }" << std::endl @@ -3817,25 +3834,25 @@ void writeTypeStruct( std::ofstream & ofs, VkData const& vkData, DependencyData if (!containsUnion(dependencyData.name, vkData.structs)) { // two structs are compared by comparing each of the elements - ofs << " bool operator==( " << dependencyData.name << " const& rhs ) const" << std::endl + os << " bool operator==( " << dependencyData.name << " const& rhs ) const" << std::endl << " {" << std::endl << " return "; for (size_t i = 0; i < it->second.members.size(); i++) { if (i != 0) { - ofs << std::endl << " && "; + os << std::endl << " && "; } if (!it->second.members[i].arraySize.empty()) { - ofs << "( memcmp( " << it->second.members[i].name << ", rhs." << it->second.members[i].name << ", " << it->second.members[i].arraySize << " * sizeof( " << it->second.members[i].type << " ) ) == 0 )"; + os << "( memcmp( " << it->second.members[i].name << ", rhs." << it->second.members[i].name << ", " << it->second.members[i].arraySize << " * sizeof( " << it->second.members[i].type << " ) ) == 0 )"; } else { - ofs << "( " << it->second.members[i].name << " == rhs." << it->second.members[i].name << " )"; + os << "( " << it->second.members[i].name << " == rhs." << it->second.members[i].name << " )"; } } - ofs << ";" << std::endl + os << ";" << std::endl << " }" << std::endl << std::endl << " bool operator!=( " << dependencyData.name << " const& rhs ) const" << std::endl @@ -3851,50 +3868,50 @@ void writeTypeStruct( std::ofstream & ofs, VkData const& vkData, DependencyData if (it->second.members[i].type == "StructureType") { assert((i == 0) && (it->second.members[i].name == "sType")); - ofs << " private:" << std::endl + os << " private:" << std::endl << " StructureType sType;" << std::endl << std::endl << " public:" << std::endl; } else { - ofs << " " << it->second.members[i].type << " " << it->second.members[i].name; + os << " " << it->second.members[i].type << " " << it->second.members[i].name; if (!it->second.members[i].arraySize.empty()) { - ofs << "[" << it->second.members[i].arraySize << "]"; + os << "[" << it->second.members[i].arraySize << "]"; } - ofs << ";" << std::endl; + os << ";" << std::endl; } } - ofs << " };" << std::endl + os << " };" << std::endl << " static_assert( sizeof( " << dependencyData.name << " ) == sizeof( Vk" << dependencyData.name << " ), \"struct and wrapper have different size!\" );" << std::endl; - leaveProtect(ofs, it->second.protect); - ofs << std::endl; + leaveProtect(os, it->second.protect); + os << std::endl; } -void writeTypeUnion( std::ofstream & ofs, VkData const& vkData, DependencyData const& dependencyData, std::map const& defaultValues ) +void writeTypeUnion( std::ostream & os, VkData const& vkData, DependencyData const& dependencyData, std::map const& defaultValues ) { std::map::const_iterator it = vkData.structs.find(dependencyData.name); assert(it != vkData.structs.end()); std::ostringstream oss; - ofs << " union " << dependencyData.name << std::endl + os << " union " << dependencyData.name << std::endl << " {" << std::endl; for ( size_t i=0 ; isecond.members.size() ; i++ ) { // one constructor per union element - ofs << " " << dependencyData.name << "( "; + os << " " << dependencyData.name << "( "; if ( it->second.members[i].arraySize.empty() ) { - ofs << it->second.members[i].type << " "; + os << it->second.members[i].type << " "; } else { - ofs << "const std::array<" << it->second.members[i].type << "," << it->second.members[i].arraySize << ">& "; + os << "const std::array<" << it->second.members[i].type << "," << it->second.members[i].arraySize << ">& "; } - ofs << it->second.members[i].name << "_"; + os << it->second.members[i].name << "_"; // just the very first constructor gets default arguments if ( i == 0 ) @@ -3903,25 +3920,25 @@ void writeTypeUnion( std::ofstream & ofs, VkData const& vkData, DependencyData c assert(defaultIt != defaultValues.end() ); if ( it->second.members[i].arraySize.empty() ) { - ofs << " = " << defaultIt->second; + os << " = " << defaultIt->second; } else { - ofs << " = { {" << defaultIt->second << "} }"; + os << " = { {" << defaultIt->second << "} }"; } } - ofs << " )" << std::endl + os << " )" << std::endl << " {" << std::endl << " "; if ( it->second.members[i].arraySize.empty() ) { - ofs << it->second.members[i].name << " = " << it->second.members[i].name << "_"; + os << it->second.members[i].name << " = " << it->second.members[i].name << "_"; } else { - ofs << "memcpy( &" << it->second.members[i].name << ", " << it->second.members[i].name << "_.data(), " << it->second.members[i].arraySize << " * sizeof( " << it->second.members[i].type << " ) )"; + os << "memcpy( &" << it->second.members[i].name << ", " << it->second.members[i].name << "_.data(), " << it->second.members[i].arraySize << " * sizeof( " << it->second.members[i].type << " ) )"; } - ofs << ";" << std::endl + os << ";" << std::endl << " }" << std::endl << std::endl; } @@ -3930,11 +3947,11 @@ void writeTypeUnion( std::ofstream & ofs, VkData const& vkData, DependencyData c { // one setter per union element assert(!it->second.returnedOnly); - writeStructSetter(ofs, dependencyData.name, it->second.members[i], vkData.vkTypes); + writeStructSetter(os, dependencyData.name, it->second.members[i], vkData.vkTypes); } // the implicit cast operator to the native type - ofs << " operator Vk" << dependencyData.name << " const& () const" << std::endl + os << " operator Vk" << dependencyData.name << " const& () const" << std::endl << " {" << std::endl << " return *reinterpret_cast(this);" << std::endl << " }" << std::endl @@ -3949,56 +3966,56 @@ void writeTypeUnion( std::ofstream & ofs, VkData const& vkData, DependencyData c } if (needsUnrestrictedUnions) { - ofs << "#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS" << std::endl; + os << "#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS" << std::endl; for (size_t i = 0; i < it->second.members.size(); i++) { - ofs << " " << it->second.members[i].type << " " << it->second.members[i].name; + os << " " << it->second.members[i].type << " " << it->second.members[i].name; if (!it->second.members[i].arraySize.empty()) { - ofs << "[" << it->second.members[i].arraySize << "]"; + os << "[" << it->second.members[i].arraySize << "]"; } - ofs << ";" << std::endl; + os << ";" << std::endl; } - ofs << "#else" << std::endl; + os << "#else" << std::endl; } for (size_t i = 0; i < it->second.members.size(); i++) { - ofs << " "; + os << " "; if (vkData.vkTypes.find(it->second.members[i].type) != vkData.vkTypes.end()) { - ofs << "Vk"; + os << "Vk"; } - ofs << it->second.members[i].type << " " << it->second.members[i].name; + os << it->second.members[i].type << " " << it->second.members[i].name; if (!it->second.members[i].arraySize.empty()) { - ofs << "[" << it->second.members[i].arraySize << "]"; + os << "[" << it->second.members[i].arraySize << "]"; } - ofs << ";" << std::endl; + os << ";" << std::endl; } if (needsUnrestrictedUnions) { - ofs << "#endif // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS" << std::endl; + os << "#endif // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS" << std::endl; } - ofs << " };" << std::endl + os << " };" << std::endl << std::endl; } -void writeTypes(std::ofstream & ofs, VkData const& vkData, std::map const& defaultValues) +void writeTypes(std::ostream & os, VkData const& vkData, std::map const& defaultValues) { for ( std::list::const_iterator it = vkData.dependencies.begin() ; it != vkData.dependencies.end() ; ++it ) { switch( it->category ) { case DependencyData::Category::COMMAND : - writeTypeCommand( ofs, vkData, *it ); + writeTypeCommand( os, vkData, *it ); break; case DependencyData::Category::ENUM : assert( vkData.enums.find( it->name ) != vkData.enums.end() ); - writeTypeEnum( ofs, vkData.enums.find( it->name )->second ); + writeTypeEnum( os, vkData.enums.find( it->name )->second ); break; case DependencyData::Category::FLAGS : assert(vkData.flags.find(it->name) != vkData.flags.end()); - writeTypeFlags( ofs, it->name, vkData.flags.find( it->name)->second, vkData.enums.find(generateEnumNameForFlags(it->name))->second ); + writeTypeFlags( os, it->name, vkData.flags.find( it->name)->second, vkData.enums.find(generateEnumNameForFlags(it->name))->second ); break; case DependencyData::Category::FUNC_POINTER : case DependencyData::Category::REQUIRED : @@ -4006,17 +4023,17 @@ void writeTypes(std::ofstream & ofs, VkData const& vkData, std::mapname) != vkData.handles.end()); - writeTypeHandle(ofs, vkData, *it, vkData.handles.find(it->name)->second, vkData.dependencies); + writeTypeHandle(os, vkData, *it, vkData.handles.find(it->name)->second, vkData.dependencies); break; case DependencyData::Category::SCALAR : - writeTypeScalar( ofs, *it ); + writeTypeScalar( os, *it ); break; case DependencyData::Category::STRUCT : - writeTypeStruct( ofs, vkData, *it, defaultValues ); + writeTypeStruct( os, vkData, *it, defaultValues ); break; case DependencyData::Category::UNION : assert( vkData.structs.find( it->name ) != vkData.structs.end() ); - writeTypeUnion( ofs, vkData, *it, defaultValues ); + writeTypeUnion( os, vkData, *it, defaultValues ); break; default : assert( false ); @@ -4025,15 +4042,15 @@ void writeTypes(std::ofstream & ofs, VkData const& vkData, std::map" << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#include " << std::endl - << "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE" << std::endl - << "# include " << std::endl - << "# include " << std::endl - << "#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/" << std::endl - << std::endl; + << R"( +#ifndef VULKAN_HPP +#define VULKAN_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE +# include +# include +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +)"; writeVersionCheck(ofs, vkData.version); writeTypesafeCheck(ofs, vkData.typesafeCheck); diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 32b0668..2e454ef 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -21,7 +21,6 @@ // This header is generated from the Khronos Vulkan XML API Registry. - #ifndef VULKAN_HPP #define VULKAN_HPP @@ -41,7 +40,6 @@ # include # include #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - static_assert( VK_HEADER_VERSION == 48 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. @@ -582,185 +580,165 @@ namespace vk class OutOfHostMemoryError : public SystemError { - public: + public: OutOfHostMemoryError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorOutOfHostMemory), message) {} + : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} OutOfHostMemoryError( char const * message ) - : SystemError(make_error_code(Result::eErrorOutOfHostMemory), message) {} + : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} }; - class OutOfDeviceMemoryError : public SystemError { - public: + public: OutOfDeviceMemoryError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorOutOfDeviceMemory), message) {} + : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} OutOfDeviceMemoryError( char const * message ) - : SystemError(make_error_code(Result::eErrorOutOfDeviceMemory), message) {} + : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} }; - class InitializationFailedError : public SystemError { - public: + public: InitializationFailedError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorInitializationFailed), message) {} + : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} InitializationFailedError( char const * message ) - : SystemError(make_error_code(Result::eErrorInitializationFailed), message) {} + : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} }; - class DeviceLostError : public SystemError { - public: + public: DeviceLostError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorDeviceLost), message) {} + : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} DeviceLostError( char const * message ) - : SystemError(make_error_code(Result::eErrorDeviceLost), message) {} + : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} }; - class MemoryMapFailedError : public SystemError { - public: + public: MemoryMapFailedError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorMemoryMapFailed), message) {} + : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} MemoryMapFailedError( char const * message ) - : SystemError(make_error_code(Result::eErrorMemoryMapFailed), message) {} + : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} }; - class LayerNotPresentError : public SystemError { - public: + public: LayerNotPresentError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorLayerNotPresent), message) {} + : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} LayerNotPresentError( char const * message ) - : SystemError(make_error_code(Result::eErrorLayerNotPresent), message) {} + : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} }; - class ExtensionNotPresentError : public SystemError { - public: + public: ExtensionNotPresentError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorExtensionNotPresent), message) {} + : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} ExtensionNotPresentError( char const * message ) - : SystemError(make_error_code(Result::eErrorExtensionNotPresent), message) {} + : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} }; - class FeatureNotPresentError : public SystemError { - public: + public: FeatureNotPresentError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorFeatureNotPresent), message) {} + : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} FeatureNotPresentError( char const * message ) - : SystemError(make_error_code(Result::eErrorFeatureNotPresent), message) {} + : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} }; - class IncompatibleDriverError : public SystemError { - public: + public: IncompatibleDriverError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorIncompatibleDriver), message) {} + : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} IncompatibleDriverError( char const * message ) - : SystemError(make_error_code(Result::eErrorIncompatibleDriver), message) {} + : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} }; - class TooManyObjectsError : public SystemError { - public: + public: TooManyObjectsError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorTooManyObjects), message) {} + : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} TooManyObjectsError( char const * message ) - : SystemError(make_error_code(Result::eErrorTooManyObjects), message) {} + : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} }; - class FormatNotSupportedError : public SystemError { - public: + public: FormatNotSupportedError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorFormatNotSupported), message) {} + : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} FormatNotSupportedError( char const * message ) - : SystemError(make_error_code(Result::eErrorFormatNotSupported), message) {} + : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} }; - class FragmentedPoolError : public SystemError { - public: + public: FragmentedPoolError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorFragmentedPool), message) {} + : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} FragmentedPoolError( char const * message ) - : SystemError(make_error_code(Result::eErrorFragmentedPool), message) {} + : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} }; - class SurfaceLostKHRError : public SystemError { - public: + public: SurfaceLostKHRError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorSurfaceLostKHR), message) {} + : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} SurfaceLostKHRError( char const * message ) - : SystemError(make_error_code(Result::eErrorSurfaceLostKHR), message) {} + : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} }; - class NativeWindowInUseKHRError : public SystemError { - public: + public: NativeWindowInUseKHRError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorNativeWindowInUseKHR), message) {} + : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} NativeWindowInUseKHRError( char const * message ) - : SystemError(make_error_code(Result::eErrorNativeWindowInUseKHR), message) {} + : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} }; - class OutOfDateKHRError : public SystemError { - public: + public: OutOfDateKHRError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorOutOfDateKHR), message) {} + : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} OutOfDateKHRError( char const * message ) - : SystemError(make_error_code(Result::eErrorOutOfDateKHR), message) {} + : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} }; - class IncompatibleDisplayKHRError : public SystemError { - public: + public: IncompatibleDisplayKHRError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorIncompatibleDisplayKHR), message) {} + : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} IncompatibleDisplayKHRError( char const * message ) - : SystemError(make_error_code(Result::eErrorIncompatibleDisplayKHR), message) {} + : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} }; - class ValidationFailedEXTError : public SystemError { - public: + public: ValidationFailedEXTError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorValidationFailedEXT), message) {} + : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} ValidationFailedEXTError( char const * message ) - : SystemError(make_error_code(Result::eErrorValidationFailedEXT), message) {} + : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} }; - class InvalidShaderNVError : public SystemError { - public: + public: InvalidShaderNVError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorInvalidShaderNV), message) {} + : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} InvalidShaderNVError( char const * message ) - : SystemError(make_error_code(Result::eErrorInvalidShaderNV), message) {} + : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} }; - class OutOfPoolMemoryKHRError : public SystemError { - public: + public: OutOfPoolMemoryKHRError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorOutOfPoolMemoryKHR), message) {} + : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {} OutOfPoolMemoryKHRError( char const * message ) - : SystemError(make_error_code(Result::eErrorOutOfPoolMemoryKHR), message) {} + : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {} }; - class InvalidExternalHandleKHXError : public SystemError { - public: + public: InvalidExternalHandleKHXError( std::string const& message ) - : SystemError(make_error_code(Result::eErrorInvalidExternalHandleKHX), message) {} + : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHX ), message ) {} InvalidExternalHandleKHXError( char const * message ) - : SystemError(make_error_code(Result::eErrorInvalidExternalHandleKHX), message) {} + : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHX ), message ) {} }; - VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) { assert ( static_cast(result) < 0 ); @@ -1190,39 +1168,41 @@ namespace vk : m_deviceMemory(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory(VkDeviceMemory deviceMemory) - : m_deviceMemory(deviceMemory) + VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) + : m_deviceMemory( deviceMemory ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DeviceMemory& operator=(VkDeviceMemory deviceMemory) + DeviceMemory & operator=(VkDeviceMemory deviceMemory) { m_deviceMemory = deviceMemory; - return *this; + return *this; } #endif - DeviceMemory& operator=( std::nullptr_t ) + DeviceMemory & operator=( std::nullptr_t ) { m_deviceMemory = VK_NULL_HANDLE; return *this; } - bool operator==(DeviceMemory const &rhs) const + bool operator==( DeviceMemory const & rhs ) const { return m_deviceMemory == rhs.m_deviceMemory; } - bool operator!=(DeviceMemory const &rhs) const + bool operator!=(DeviceMemory const & rhs ) const { return m_deviceMemory != rhs.m_deviceMemory; } - bool operator<(DeviceMemory const &rhs) const + bool operator<(DeviceMemory const & rhs ) const { return m_deviceMemory < rhs.m_deviceMemory; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const { return m_deviceMemory; @@ -1241,6 +1221,7 @@ namespace vk private: VkDeviceMemory m_deviceMemory; }; + static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); class CommandPool @@ -1254,39 +1235,41 @@ namespace vk : m_commandPool(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool(VkCommandPool commandPool) - : m_commandPool(commandPool) + VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) + : m_commandPool( commandPool ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - CommandPool& operator=(VkCommandPool commandPool) + CommandPool & operator=(VkCommandPool commandPool) { m_commandPool = commandPool; - return *this; + return *this; } #endif - CommandPool& operator=( std::nullptr_t ) + CommandPool & operator=( std::nullptr_t ) { m_commandPool = VK_NULL_HANDLE; return *this; } - bool operator==(CommandPool const &rhs) const + bool operator==( CommandPool const & rhs ) const { return m_commandPool == rhs.m_commandPool; } - bool operator!=(CommandPool const &rhs) const + bool operator!=(CommandPool const & rhs ) const { return m_commandPool != rhs.m_commandPool; } - bool operator<(CommandPool const &rhs) const + bool operator<(CommandPool const & rhs ) const { return m_commandPool < rhs.m_commandPool; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const { return m_commandPool; @@ -1305,6 +1288,7 @@ namespace vk private: VkCommandPool m_commandPool; }; + static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); class Buffer @@ -1318,39 +1302,41 @@ namespace vk : m_buffer(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Buffer(VkBuffer buffer) - : m_buffer(buffer) + VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) + : m_buffer( buffer ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Buffer& operator=(VkBuffer buffer) + Buffer & operator=(VkBuffer buffer) { m_buffer = buffer; - return *this; + return *this; } #endif - Buffer& operator=( std::nullptr_t ) + Buffer & operator=( std::nullptr_t ) { m_buffer = VK_NULL_HANDLE; return *this; } - bool operator==(Buffer const &rhs) const + bool operator==( Buffer const & rhs ) const { return m_buffer == rhs.m_buffer; } - bool operator!=(Buffer const &rhs) const + bool operator!=(Buffer const & rhs ) const { return m_buffer != rhs.m_buffer; } - bool operator<(Buffer const &rhs) const + bool operator<(Buffer const & rhs ) const { return m_buffer < rhs.m_buffer; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const { return m_buffer; @@ -1369,6 +1355,7 @@ namespace vk private: VkBuffer m_buffer; }; + static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); class BufferView @@ -1382,39 +1369,41 @@ namespace vk : m_bufferView(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT BufferView(VkBufferView bufferView) - : m_bufferView(bufferView) + VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) + : m_bufferView( bufferView ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - BufferView& operator=(VkBufferView bufferView) + BufferView & operator=(VkBufferView bufferView) { m_bufferView = bufferView; - return *this; + return *this; } #endif - BufferView& operator=( std::nullptr_t ) + BufferView & operator=( std::nullptr_t ) { m_bufferView = VK_NULL_HANDLE; return *this; } - bool operator==(BufferView const &rhs) const + bool operator==( BufferView const & rhs ) const { return m_bufferView == rhs.m_bufferView; } - bool operator!=(BufferView const &rhs) const + bool operator!=(BufferView const & rhs ) const { return m_bufferView != rhs.m_bufferView; } - bool operator<(BufferView const &rhs) const + bool operator<(BufferView const & rhs ) const { return m_bufferView < rhs.m_bufferView; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const { return m_bufferView; @@ -1433,6 +1422,7 @@ namespace vk private: VkBufferView m_bufferView; }; + static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); class Image @@ -1446,39 +1436,41 @@ namespace vk : m_image(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Image(VkImage image) - : m_image(image) + VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) + : m_image( image ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Image& operator=(VkImage image) + Image & operator=(VkImage image) { m_image = image; - return *this; + return *this; } #endif - Image& operator=( std::nullptr_t ) + Image & operator=( std::nullptr_t ) { m_image = VK_NULL_HANDLE; return *this; } - bool operator==(Image const &rhs) const + bool operator==( Image const & rhs ) const { return m_image == rhs.m_image; } - bool operator!=(Image const &rhs) const + bool operator!=(Image const & rhs ) const { return m_image != rhs.m_image; } - bool operator<(Image const &rhs) const + bool operator<(Image const & rhs ) const { return m_image < rhs.m_image; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const { return m_image; @@ -1497,6 +1489,7 @@ namespace vk private: VkImage m_image; }; + static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); class ImageView @@ -1510,39 +1503,41 @@ namespace vk : m_imageView(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT ImageView(VkImageView imageView) - : m_imageView(imageView) + VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) + : m_imageView( imageView ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ImageView& operator=(VkImageView imageView) + ImageView & operator=(VkImageView imageView) { m_imageView = imageView; - return *this; + return *this; } #endif - ImageView& operator=( std::nullptr_t ) + ImageView & operator=( std::nullptr_t ) { m_imageView = VK_NULL_HANDLE; return *this; } - bool operator==(ImageView const &rhs) const + bool operator==( ImageView const & rhs ) const { return m_imageView == rhs.m_imageView; } - bool operator!=(ImageView const &rhs) const + bool operator!=(ImageView const & rhs ) const { return m_imageView != rhs.m_imageView; } - bool operator<(ImageView const &rhs) const + bool operator<(ImageView const & rhs ) const { return m_imageView < rhs.m_imageView; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const { return m_imageView; @@ -1561,6 +1556,7 @@ namespace vk private: VkImageView m_imageView; }; + static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); class ShaderModule @@ -1574,39 +1570,41 @@ namespace vk : m_shaderModule(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule(VkShaderModule shaderModule) - : m_shaderModule(shaderModule) + VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) + : m_shaderModule( shaderModule ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ShaderModule& operator=(VkShaderModule shaderModule) + ShaderModule & operator=(VkShaderModule shaderModule) { m_shaderModule = shaderModule; - return *this; + return *this; } #endif - ShaderModule& operator=( std::nullptr_t ) + ShaderModule & operator=( std::nullptr_t ) { m_shaderModule = VK_NULL_HANDLE; return *this; } - bool operator==(ShaderModule const &rhs) const + bool operator==( ShaderModule const & rhs ) const { return m_shaderModule == rhs.m_shaderModule; } - bool operator!=(ShaderModule const &rhs) const + bool operator!=(ShaderModule const & rhs ) const { return m_shaderModule != rhs.m_shaderModule; } - bool operator<(ShaderModule const &rhs) const + bool operator<(ShaderModule const & rhs ) const { return m_shaderModule < rhs.m_shaderModule; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const { return m_shaderModule; @@ -1625,6 +1623,7 @@ namespace vk private: VkShaderModule m_shaderModule; }; + static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); class Pipeline @@ -1638,39 +1637,41 @@ namespace vk : m_pipeline(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline(VkPipeline pipeline) - : m_pipeline(pipeline) + VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) + : m_pipeline( pipeline ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Pipeline& operator=(VkPipeline pipeline) + Pipeline & operator=(VkPipeline pipeline) { m_pipeline = pipeline; - return *this; + return *this; } #endif - Pipeline& operator=( std::nullptr_t ) + Pipeline & operator=( std::nullptr_t ) { m_pipeline = VK_NULL_HANDLE; return *this; } - bool operator==(Pipeline const &rhs) const + bool operator==( Pipeline const & rhs ) const { return m_pipeline == rhs.m_pipeline; } - bool operator!=(Pipeline const &rhs) const + bool operator!=(Pipeline const & rhs ) const { return m_pipeline != rhs.m_pipeline; } - bool operator<(Pipeline const &rhs) const + bool operator<(Pipeline const & rhs ) const { return m_pipeline < rhs.m_pipeline; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const { return m_pipeline; @@ -1689,6 +1690,7 @@ namespace vk private: VkPipeline m_pipeline; }; + static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); class PipelineLayout @@ -1702,39 +1704,41 @@ namespace vk : m_pipelineLayout(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout(VkPipelineLayout pipelineLayout) - : m_pipelineLayout(pipelineLayout) + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) + : m_pipelineLayout( pipelineLayout ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PipelineLayout& operator=(VkPipelineLayout pipelineLayout) + PipelineLayout & operator=(VkPipelineLayout pipelineLayout) { m_pipelineLayout = pipelineLayout; - return *this; + return *this; } #endif - PipelineLayout& operator=( std::nullptr_t ) + PipelineLayout & operator=( std::nullptr_t ) { m_pipelineLayout = VK_NULL_HANDLE; return *this; } - bool operator==(PipelineLayout const &rhs) const + bool operator==( PipelineLayout const & rhs ) const { return m_pipelineLayout == rhs.m_pipelineLayout; } - bool operator!=(PipelineLayout const &rhs) const + bool operator!=(PipelineLayout const & rhs ) const { return m_pipelineLayout != rhs.m_pipelineLayout; } - bool operator<(PipelineLayout const &rhs) const + bool operator<(PipelineLayout const & rhs ) const { return m_pipelineLayout < rhs.m_pipelineLayout; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const { return m_pipelineLayout; @@ -1753,6 +1757,7 @@ namespace vk private: VkPipelineLayout m_pipelineLayout; }; + static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); class Sampler @@ -1766,39 +1771,41 @@ namespace vk : m_sampler(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Sampler(VkSampler sampler) - : m_sampler(sampler) + VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) + : m_sampler( sampler ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Sampler& operator=(VkSampler sampler) + Sampler & operator=(VkSampler sampler) { m_sampler = sampler; - return *this; + return *this; } #endif - Sampler& operator=( std::nullptr_t ) + Sampler & operator=( std::nullptr_t ) { m_sampler = VK_NULL_HANDLE; return *this; } - bool operator==(Sampler const &rhs) const + bool operator==( Sampler const & rhs ) const { return m_sampler == rhs.m_sampler; } - bool operator!=(Sampler const &rhs) const + bool operator!=(Sampler const & rhs ) const { return m_sampler != rhs.m_sampler; } - bool operator<(Sampler const &rhs) const + bool operator<(Sampler const & rhs ) const { return m_sampler < rhs.m_sampler; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const { return m_sampler; @@ -1817,6 +1824,7 @@ namespace vk private: VkSampler m_sampler; }; + static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); class DescriptorSet @@ -1830,39 +1838,41 @@ namespace vk : m_descriptorSet(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet(VkDescriptorSet descriptorSet) - : m_descriptorSet(descriptorSet) + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) + : m_descriptorSet( descriptorSet ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorSet& operator=(VkDescriptorSet descriptorSet) + DescriptorSet & operator=(VkDescriptorSet descriptorSet) { m_descriptorSet = descriptorSet; - return *this; + return *this; } #endif - DescriptorSet& operator=( std::nullptr_t ) + DescriptorSet & operator=( std::nullptr_t ) { m_descriptorSet = VK_NULL_HANDLE; return *this; } - bool operator==(DescriptorSet const &rhs) const + bool operator==( DescriptorSet const & rhs ) const { return m_descriptorSet == rhs.m_descriptorSet; } - bool operator!=(DescriptorSet const &rhs) const + bool operator!=(DescriptorSet const & rhs ) const { return m_descriptorSet != rhs.m_descriptorSet; } - bool operator<(DescriptorSet const &rhs) const + bool operator<(DescriptorSet const & rhs ) const { return m_descriptorSet < rhs.m_descriptorSet; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const { return m_descriptorSet; @@ -1881,6 +1891,7 @@ namespace vk private: VkDescriptorSet m_descriptorSet; }; + static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); class DescriptorSetLayout @@ -1894,39 +1905,41 @@ namespace vk : m_descriptorSetLayout(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) - : m_descriptorSetLayout(descriptorSetLayout) + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) + : m_descriptorSetLayout( descriptorSetLayout ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorSetLayout& operator=(VkDescriptorSetLayout descriptorSetLayout) + DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) { m_descriptorSetLayout = descriptorSetLayout; - return *this; + return *this; } #endif - DescriptorSetLayout& operator=( std::nullptr_t ) + DescriptorSetLayout & operator=( std::nullptr_t ) { m_descriptorSetLayout = VK_NULL_HANDLE; return *this; } - bool operator==(DescriptorSetLayout const &rhs) const + bool operator==( DescriptorSetLayout const & rhs ) const { return m_descriptorSetLayout == rhs.m_descriptorSetLayout; } - bool operator!=(DescriptorSetLayout const &rhs) const + bool operator!=(DescriptorSetLayout const & rhs ) const { return m_descriptorSetLayout != rhs.m_descriptorSetLayout; } - bool operator<(DescriptorSetLayout const &rhs) const + bool operator<(DescriptorSetLayout const & rhs ) const { return m_descriptorSetLayout < rhs.m_descriptorSetLayout; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const { return m_descriptorSetLayout; @@ -1945,6 +1958,7 @@ namespace vk private: VkDescriptorSetLayout m_descriptorSetLayout; }; + static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); class DescriptorPool @@ -1958,39 +1972,41 @@ namespace vk : m_descriptorPool(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool(VkDescriptorPool descriptorPool) - : m_descriptorPool(descriptorPool) + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) + : m_descriptorPool( descriptorPool ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorPool& operator=(VkDescriptorPool descriptorPool) + DescriptorPool & operator=(VkDescriptorPool descriptorPool) { m_descriptorPool = descriptorPool; - return *this; + return *this; } #endif - DescriptorPool& operator=( std::nullptr_t ) + DescriptorPool & operator=( std::nullptr_t ) { m_descriptorPool = VK_NULL_HANDLE; return *this; } - bool operator==(DescriptorPool const &rhs) const + bool operator==( DescriptorPool const & rhs ) const { return m_descriptorPool == rhs.m_descriptorPool; } - bool operator!=(DescriptorPool const &rhs) const + bool operator!=(DescriptorPool const & rhs ) const { return m_descriptorPool != rhs.m_descriptorPool; } - bool operator<(DescriptorPool const &rhs) const + bool operator<(DescriptorPool const & rhs ) const { return m_descriptorPool < rhs.m_descriptorPool; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const { return m_descriptorPool; @@ -2009,6 +2025,7 @@ namespace vk private: VkDescriptorPool m_descriptorPool; }; + static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); class Fence @@ -2022,39 +2039,41 @@ namespace vk : m_fence(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Fence(VkFence fence) - : m_fence(fence) + VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) + : m_fence( fence ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Fence& operator=(VkFence fence) + Fence & operator=(VkFence fence) { m_fence = fence; - return *this; + return *this; } #endif - Fence& operator=( std::nullptr_t ) + Fence & operator=( std::nullptr_t ) { m_fence = VK_NULL_HANDLE; return *this; } - bool operator==(Fence const &rhs) const + bool operator==( Fence const & rhs ) const { return m_fence == rhs.m_fence; } - bool operator!=(Fence const &rhs) const + bool operator!=(Fence const & rhs ) const { return m_fence != rhs.m_fence; } - bool operator<(Fence const &rhs) const + bool operator<(Fence const & rhs ) const { return m_fence < rhs.m_fence; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const { return m_fence; @@ -2073,6 +2092,7 @@ namespace vk private: VkFence m_fence; }; + static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); class Semaphore @@ -2086,39 +2106,41 @@ namespace vk : m_semaphore(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore(VkSemaphore semaphore) - : m_semaphore(semaphore) + VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) + : m_semaphore( semaphore ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Semaphore& operator=(VkSemaphore semaphore) + Semaphore & operator=(VkSemaphore semaphore) { m_semaphore = semaphore; - return *this; + return *this; } #endif - Semaphore& operator=( std::nullptr_t ) + Semaphore & operator=( std::nullptr_t ) { m_semaphore = VK_NULL_HANDLE; return *this; } - bool operator==(Semaphore const &rhs) const + bool operator==( Semaphore const & rhs ) const { return m_semaphore == rhs.m_semaphore; } - bool operator!=(Semaphore const &rhs) const + bool operator!=(Semaphore const & rhs ) const { return m_semaphore != rhs.m_semaphore; } - bool operator<(Semaphore const &rhs) const + bool operator<(Semaphore const & rhs ) const { return m_semaphore < rhs.m_semaphore; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const { return m_semaphore; @@ -2137,6 +2159,7 @@ namespace vk private: VkSemaphore m_semaphore; }; + static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); class Event @@ -2150,39 +2173,41 @@ namespace vk : m_event(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Event(VkEvent event) - : m_event(event) + VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) + : m_event( event ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Event& operator=(VkEvent event) + Event & operator=(VkEvent event) { m_event = event; - return *this; + return *this; } #endif - Event& operator=( std::nullptr_t ) + Event & operator=( std::nullptr_t ) { m_event = VK_NULL_HANDLE; return *this; } - bool operator==(Event const &rhs) const + bool operator==( Event const & rhs ) const { return m_event == rhs.m_event; } - bool operator!=(Event const &rhs) const + bool operator!=(Event const & rhs ) const { return m_event != rhs.m_event; } - bool operator<(Event const &rhs) const + bool operator<(Event const & rhs ) const { return m_event < rhs.m_event; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const { return m_event; @@ -2201,6 +2226,7 @@ namespace vk private: VkEvent m_event; }; + static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); class QueryPool @@ -2214,39 +2240,41 @@ namespace vk : m_queryPool(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool(VkQueryPool queryPool) - : m_queryPool(queryPool) + VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) + : m_queryPool( queryPool ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - QueryPool& operator=(VkQueryPool queryPool) + QueryPool & operator=(VkQueryPool queryPool) { m_queryPool = queryPool; - return *this; + return *this; } #endif - QueryPool& operator=( std::nullptr_t ) + QueryPool & operator=( std::nullptr_t ) { m_queryPool = VK_NULL_HANDLE; return *this; } - bool operator==(QueryPool const &rhs) const + bool operator==( QueryPool const & rhs ) const { return m_queryPool == rhs.m_queryPool; } - bool operator!=(QueryPool const &rhs) const + bool operator!=(QueryPool const & rhs ) const { return m_queryPool != rhs.m_queryPool; } - bool operator<(QueryPool const &rhs) const + bool operator<(QueryPool const & rhs ) const { return m_queryPool < rhs.m_queryPool; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const { return m_queryPool; @@ -2265,6 +2293,7 @@ namespace vk private: VkQueryPool m_queryPool; }; + static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); class Framebuffer @@ -2278,39 +2307,41 @@ namespace vk : m_framebuffer(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer(VkFramebuffer framebuffer) - : m_framebuffer(framebuffer) + VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) + : m_framebuffer( framebuffer ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Framebuffer& operator=(VkFramebuffer framebuffer) + Framebuffer & operator=(VkFramebuffer framebuffer) { m_framebuffer = framebuffer; - return *this; + return *this; } #endif - Framebuffer& operator=( std::nullptr_t ) + Framebuffer & operator=( std::nullptr_t ) { m_framebuffer = VK_NULL_HANDLE; return *this; } - bool operator==(Framebuffer const &rhs) const + bool operator==( Framebuffer const & rhs ) const { return m_framebuffer == rhs.m_framebuffer; } - bool operator!=(Framebuffer const &rhs) const + bool operator!=(Framebuffer const & rhs ) const { return m_framebuffer != rhs.m_framebuffer; } - bool operator<(Framebuffer const &rhs) const + bool operator<(Framebuffer const & rhs ) const { return m_framebuffer < rhs.m_framebuffer; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const { return m_framebuffer; @@ -2329,6 +2360,7 @@ namespace vk private: VkFramebuffer m_framebuffer; }; + static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); class RenderPass @@ -2342,39 +2374,41 @@ namespace vk : m_renderPass(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass(VkRenderPass renderPass) - : m_renderPass(renderPass) + VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) + : m_renderPass( renderPass ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - RenderPass& operator=(VkRenderPass renderPass) + RenderPass & operator=(VkRenderPass renderPass) { m_renderPass = renderPass; - return *this; + return *this; } #endif - RenderPass& operator=( std::nullptr_t ) + RenderPass & operator=( std::nullptr_t ) { m_renderPass = VK_NULL_HANDLE; return *this; } - bool operator==(RenderPass const &rhs) const + bool operator==( RenderPass const & rhs ) const { return m_renderPass == rhs.m_renderPass; } - bool operator!=(RenderPass const &rhs) const + bool operator!=(RenderPass const & rhs ) const { return m_renderPass != rhs.m_renderPass; } - bool operator<(RenderPass const &rhs) const + bool operator<(RenderPass const & rhs ) const { return m_renderPass < rhs.m_renderPass; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const { return m_renderPass; @@ -2393,6 +2427,7 @@ namespace vk private: VkRenderPass m_renderPass; }; + static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); class PipelineCache @@ -2406,39 +2441,41 @@ namespace vk : m_pipelineCache(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache(VkPipelineCache pipelineCache) - : m_pipelineCache(pipelineCache) + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) + : m_pipelineCache( pipelineCache ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PipelineCache& operator=(VkPipelineCache pipelineCache) + PipelineCache & operator=(VkPipelineCache pipelineCache) { m_pipelineCache = pipelineCache; - return *this; + return *this; } #endif - PipelineCache& operator=( std::nullptr_t ) + PipelineCache & operator=( std::nullptr_t ) { m_pipelineCache = VK_NULL_HANDLE; return *this; } - bool operator==(PipelineCache const &rhs) const + bool operator==( PipelineCache const & rhs ) const { return m_pipelineCache == rhs.m_pipelineCache; } - bool operator!=(PipelineCache const &rhs) const + bool operator!=(PipelineCache const & rhs ) const { return m_pipelineCache != rhs.m_pipelineCache; } - bool operator<(PipelineCache const &rhs) const + bool operator<(PipelineCache const & rhs ) const { return m_pipelineCache < rhs.m_pipelineCache; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const { return m_pipelineCache; @@ -2457,6 +2494,7 @@ namespace vk private: VkPipelineCache m_pipelineCache; }; + static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); class ObjectTableNVX @@ -2470,39 +2508,41 @@ namespace vk : m_objectTableNVX(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX(VkObjectTableNVX objectTableNVX) - : m_objectTableNVX(objectTableNVX) + VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX ) + : m_objectTableNVX( objectTableNVX ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ObjectTableNVX& operator=(VkObjectTableNVX objectTableNVX) + ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX) { m_objectTableNVX = objectTableNVX; - return *this; + return *this; } #endif - ObjectTableNVX& operator=( std::nullptr_t ) + ObjectTableNVX & operator=( std::nullptr_t ) { m_objectTableNVX = VK_NULL_HANDLE; return *this; } - bool operator==(ObjectTableNVX const &rhs) const + bool operator==( ObjectTableNVX const & rhs ) const { return m_objectTableNVX == rhs.m_objectTableNVX; } - bool operator!=(ObjectTableNVX const &rhs) const + bool operator!=(ObjectTableNVX const & rhs ) const { return m_objectTableNVX != rhs.m_objectTableNVX; } - bool operator<(ObjectTableNVX const &rhs) const + bool operator<(ObjectTableNVX const & rhs ) const { return m_objectTableNVX < rhs.m_objectTableNVX; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const { return m_objectTableNVX; @@ -2521,6 +2561,7 @@ namespace vk private: VkObjectTableNVX m_objectTableNVX; }; + static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" ); class IndirectCommandsLayoutNVX @@ -2534,39 +2575,41 @@ namespace vk : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) - : m_indirectCommandsLayoutNVX(indirectCommandsLayoutNVX) + VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX ) + : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - IndirectCommandsLayoutNVX& operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) + IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) { m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX; - return *this; + return *this; } #endif - IndirectCommandsLayoutNVX& operator=( std::nullptr_t ) + IndirectCommandsLayoutNVX & operator=( std::nullptr_t ) { m_indirectCommandsLayoutNVX = VK_NULL_HANDLE; return *this; } - bool operator==(IndirectCommandsLayoutNVX const &rhs) const + bool operator==( IndirectCommandsLayoutNVX const & rhs ) const { return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX; } - bool operator!=(IndirectCommandsLayoutNVX const &rhs) const + bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const { return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX; } - bool operator<(IndirectCommandsLayoutNVX const &rhs) const + bool operator<(IndirectCommandsLayoutNVX const & rhs ) const { return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const { return m_indirectCommandsLayoutNVX; @@ -2585,6 +2628,7 @@ namespace vk private: VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX; }; + static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" ); class DescriptorUpdateTemplateKHR @@ -2598,39 +2642,41 @@ namespace vk : m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR) - : m_descriptorUpdateTemplateKHR(descriptorUpdateTemplateKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR( VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR ) + : m_descriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorUpdateTemplateKHR& operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR) + DescriptorUpdateTemplateKHR & operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR) { m_descriptorUpdateTemplateKHR = descriptorUpdateTemplateKHR; - return *this; + return *this; } #endif - DescriptorUpdateTemplateKHR& operator=( std::nullptr_t ) + DescriptorUpdateTemplateKHR & operator=( std::nullptr_t ) { m_descriptorUpdateTemplateKHR = VK_NULL_HANDLE; return *this; } - bool operator==(DescriptorUpdateTemplateKHR const &rhs) const + bool operator==( DescriptorUpdateTemplateKHR const & rhs ) const { return m_descriptorUpdateTemplateKHR == rhs.m_descriptorUpdateTemplateKHR; } - bool operator!=(DescriptorUpdateTemplateKHR const &rhs) const + bool operator!=(DescriptorUpdateTemplateKHR const & rhs ) const { return m_descriptorUpdateTemplateKHR != rhs.m_descriptorUpdateTemplateKHR; } - bool operator<(DescriptorUpdateTemplateKHR const &rhs) const + bool operator<(DescriptorUpdateTemplateKHR const & rhs ) const { return m_descriptorUpdateTemplateKHR < rhs.m_descriptorUpdateTemplateKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplateKHR() const { return m_descriptorUpdateTemplateKHR; @@ -2649,6 +2695,7 @@ namespace vk private: VkDescriptorUpdateTemplateKHR m_descriptorUpdateTemplateKHR; }; + static_assert( sizeof( DescriptorUpdateTemplateKHR ) == sizeof( VkDescriptorUpdateTemplateKHR ), "handle and wrapper have different size!" ); class DisplayKHR @@ -2662,39 +2709,41 @@ namespace vk : m_displayKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR(VkDisplayKHR displayKHR) - : m_displayKHR(displayKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) + : m_displayKHR( displayKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DisplayKHR& operator=(VkDisplayKHR displayKHR) + DisplayKHR & operator=(VkDisplayKHR displayKHR) { m_displayKHR = displayKHR; - return *this; + return *this; } #endif - DisplayKHR& operator=( std::nullptr_t ) + DisplayKHR & operator=( std::nullptr_t ) { m_displayKHR = VK_NULL_HANDLE; return *this; } - bool operator==(DisplayKHR const &rhs) const + bool operator==( DisplayKHR const & rhs ) const { return m_displayKHR == rhs.m_displayKHR; } - bool operator!=(DisplayKHR const &rhs) const + bool operator!=(DisplayKHR const & rhs ) const { return m_displayKHR != rhs.m_displayKHR; } - bool operator<(DisplayKHR const &rhs) const + bool operator<(DisplayKHR const & rhs ) const { return m_displayKHR < rhs.m_displayKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const { return m_displayKHR; @@ -2713,6 +2762,7 @@ namespace vk private: VkDisplayKHR m_displayKHR; }; + static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); class DisplayModeKHR @@ -2726,39 +2776,41 @@ namespace vk : m_displayModeKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR(VkDisplayModeKHR displayModeKHR) - : m_displayModeKHR(displayModeKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) + : m_displayModeKHR( displayModeKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DisplayModeKHR& operator=(VkDisplayModeKHR displayModeKHR) + DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) { m_displayModeKHR = displayModeKHR; - return *this; + return *this; } #endif - DisplayModeKHR& operator=( std::nullptr_t ) + DisplayModeKHR & operator=( std::nullptr_t ) { m_displayModeKHR = VK_NULL_HANDLE; return *this; } - bool operator==(DisplayModeKHR const &rhs) const + bool operator==( DisplayModeKHR const & rhs ) const { return m_displayModeKHR == rhs.m_displayModeKHR; } - bool operator!=(DisplayModeKHR const &rhs) const + bool operator!=(DisplayModeKHR const & rhs ) const { return m_displayModeKHR != rhs.m_displayModeKHR; } - bool operator<(DisplayModeKHR const &rhs) const + bool operator<(DisplayModeKHR const & rhs ) const { return m_displayModeKHR < rhs.m_displayModeKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const { return m_displayModeKHR; @@ -2777,6 +2829,7 @@ namespace vk private: VkDisplayModeKHR m_displayModeKHR; }; + static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); class SurfaceKHR @@ -2790,39 +2843,41 @@ namespace vk : m_surfaceKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR(VkSurfaceKHR surfaceKHR) - : m_surfaceKHR(surfaceKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) + : m_surfaceKHR( surfaceKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SurfaceKHR& operator=(VkSurfaceKHR surfaceKHR) + SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) { m_surfaceKHR = surfaceKHR; - return *this; + return *this; } #endif - SurfaceKHR& operator=( std::nullptr_t ) + SurfaceKHR & operator=( std::nullptr_t ) { m_surfaceKHR = VK_NULL_HANDLE; return *this; } - bool operator==(SurfaceKHR const &rhs) const + bool operator==( SurfaceKHR const & rhs ) const { return m_surfaceKHR == rhs.m_surfaceKHR; } - bool operator!=(SurfaceKHR const &rhs) const + bool operator!=(SurfaceKHR const & rhs ) const { return m_surfaceKHR != rhs.m_surfaceKHR; } - bool operator<(SurfaceKHR const &rhs) const + bool operator<(SurfaceKHR const & rhs ) const { return m_surfaceKHR < rhs.m_surfaceKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const { return m_surfaceKHR; @@ -2841,6 +2896,7 @@ namespace vk private: VkSurfaceKHR m_surfaceKHR; }; + static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); class SwapchainKHR @@ -2854,39 +2910,41 @@ namespace vk : m_swapchainKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR(VkSwapchainKHR swapchainKHR) - : m_swapchainKHR(swapchainKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) + : m_swapchainKHR( swapchainKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SwapchainKHR& operator=(VkSwapchainKHR swapchainKHR) + SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) { m_swapchainKHR = swapchainKHR; - return *this; + return *this; } #endif - SwapchainKHR& operator=( std::nullptr_t ) + SwapchainKHR & operator=( std::nullptr_t ) { m_swapchainKHR = VK_NULL_HANDLE; return *this; } - bool operator==(SwapchainKHR const &rhs) const + bool operator==( SwapchainKHR const & rhs ) const { return m_swapchainKHR == rhs.m_swapchainKHR; } - bool operator!=(SwapchainKHR const &rhs) const + bool operator!=(SwapchainKHR const & rhs ) const { return m_swapchainKHR != rhs.m_swapchainKHR; } - bool operator<(SwapchainKHR const &rhs) const + bool operator<(SwapchainKHR const & rhs ) const { return m_swapchainKHR < rhs.m_swapchainKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const { return m_swapchainKHR; @@ -2905,6 +2963,7 @@ namespace vk private: VkSwapchainKHR m_swapchainKHR; }; + static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); class DebugReportCallbackEXT @@ -2918,39 +2977,41 @@ namespace vk : m_debugReportCallbackEXT(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT) - : m_debugReportCallbackEXT(debugReportCallbackEXT) + VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) + : m_debugReportCallbackEXT( debugReportCallbackEXT ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DebugReportCallbackEXT& operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) + DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) { m_debugReportCallbackEXT = debugReportCallbackEXT; - return *this; + return *this; } #endif - DebugReportCallbackEXT& operator=( std::nullptr_t ) + DebugReportCallbackEXT & operator=( std::nullptr_t ) { m_debugReportCallbackEXT = VK_NULL_HANDLE; return *this; } - bool operator==(DebugReportCallbackEXT const &rhs) const + bool operator==( DebugReportCallbackEXT const & rhs ) const { return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT; } - bool operator!=(DebugReportCallbackEXT const &rhs) const + bool operator!=(DebugReportCallbackEXT const & rhs ) const { return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT; } - bool operator<(DebugReportCallbackEXT const &rhs) const + bool operator<(DebugReportCallbackEXT const & rhs ) const { return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const { return m_debugReportCallbackEXT; @@ -2969,6 +3030,7 @@ namespace vk private: VkDebugReportCallbackEXT m_debugReportCallbackEXT; }; + static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); struct Offset2D @@ -2981,15 +3043,14 @@ namespace vk Offset2D( VkOffset2D const & rhs ) { - memcpy( this, &rhs, sizeof(Offset2D) ); + memcpy( this, &rhs, sizeof( Offset2D ) ); } Offset2D& operator=( VkOffset2D const & rhs ) { - memcpy( this, &rhs, sizeof(Offset2D) ); + memcpy( this, &rhs, sizeof( Offset2D ) ); return *this; } - Offset2D& setX( int32_t x_ ) { x = x_; @@ -3034,15 +3095,14 @@ namespace vk Offset3D( VkOffset3D const & rhs ) { - memcpy( this, &rhs, sizeof(Offset3D) ); + memcpy( this, &rhs, sizeof( Offset3D ) ); } Offset3D& operator=( VkOffset3D const & rhs ) { - memcpy( this, &rhs, sizeof(Offset3D) ); + memcpy( this, &rhs, sizeof( Offset3D ) ); return *this; } - Offset3D& setX( int32_t x_ ) { x = x_; @@ -3094,15 +3154,14 @@ namespace vk Extent2D( VkExtent2D const & rhs ) { - memcpy( this, &rhs, sizeof(Extent2D) ); + memcpy( this, &rhs, sizeof( Extent2D ) ); } Extent2D& operator=( VkExtent2D const & rhs ) { - memcpy( this, &rhs, sizeof(Extent2D) ); + memcpy( this, &rhs, sizeof( Extent2D ) ); return *this; } - Extent2D& setWidth( uint32_t width_ ) { width = width_; @@ -3147,15 +3206,14 @@ namespace vk Extent3D( VkExtent3D const & rhs ) { - memcpy( this, &rhs, sizeof(Extent3D) ); + memcpy( this, &rhs, sizeof( Extent3D ) ); } Extent3D& operator=( VkExtent3D const & rhs ) { - memcpy( this, &rhs, sizeof(Extent3D) ); + memcpy( this, &rhs, sizeof( Extent3D ) ); return *this; } - Extent3D& setWidth( uint32_t width_ ) { width = width_; @@ -3211,15 +3269,14 @@ namespace vk Viewport( VkViewport const & rhs ) { - memcpy( this, &rhs, sizeof(Viewport) ); + memcpy( this, &rhs, sizeof( Viewport ) ); } Viewport& operator=( VkViewport const & rhs ) { - memcpy( this, &rhs, sizeof(Viewport) ); + memcpy( this, &rhs, sizeof( Viewport ) ); return *this; } - Viewport& setX( float x_ ) { x = x_; @@ -3295,15 +3352,14 @@ namespace vk Rect2D( VkRect2D const & rhs ) { - memcpy( this, &rhs, sizeof(Rect2D) ); + memcpy( this, &rhs, sizeof( Rect2D ) ); } Rect2D& operator=( VkRect2D const & rhs ) { - memcpy( this, &rhs, sizeof(Rect2D) ); + memcpy( this, &rhs, sizeof( Rect2D ) ); return *this; } - Rect2D& setOffset( Offset2D offset_ ) { offset = offset_; @@ -3348,15 +3404,14 @@ namespace vk ClearRect( VkClearRect const & rhs ) { - memcpy( this, &rhs, sizeof(ClearRect) ); + memcpy( this, &rhs, sizeof( ClearRect ) ); } ClearRect& operator=( VkClearRect const & rhs ) { - memcpy( this, &rhs, sizeof(ClearRect) ); + memcpy( this, &rhs, sizeof( ClearRect ) ); return *this; } - ClearRect& setRect( Rect2D rect_ ) { rect = rect_; @@ -3462,15 +3517,14 @@ namespace vk AllocationCallbacks( VkAllocationCallbacks const & rhs ) { - memcpy( this, &rhs, sizeof(AllocationCallbacks) ); + memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); } AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) { - memcpy( this, &rhs, sizeof(AllocationCallbacks) ); + memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); return *this; } - AllocationCallbacks& setPUserData( void* pUserData_ ) { pUserData = pUserData_; @@ -3572,15 +3626,14 @@ namespace vk DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorBufferInfo) ); + memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); } DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorBufferInfo) ); + memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); return *this; } - DescriptorBufferInfo& setBuffer( Buffer buffer_ ) { buffer = buffer_; @@ -3662,15 +3715,14 @@ namespace vk BufferCopy( VkBufferCopy const & rhs ) { - memcpy( this, &rhs, sizeof(BufferCopy) ); + memcpy( this, &rhs, sizeof( BufferCopy ) ); } BufferCopy& operator=( VkBufferCopy const & rhs ) { - memcpy( this, &rhs, sizeof(BufferCopy) ); + memcpy( this, &rhs, sizeof( BufferCopy ) ); return *this; } - BufferCopy& setSrcOffset( DeviceSize srcOffset_ ) { srcOffset = srcOffset_; @@ -3723,15 +3775,14 @@ namespace vk SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) { - memcpy( this, &rhs, sizeof(SpecializationMapEntry) ); + memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); } SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) { - memcpy( this, &rhs, sizeof(SpecializationMapEntry) ); + memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); return *this; } - SpecializationMapEntry& setConstantID( uint32_t constantID_ ) { constantID = constantID_; @@ -3785,15 +3836,14 @@ namespace vk SpecializationInfo( VkSpecializationInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SpecializationInfo) ); + memcpy( this, &rhs, sizeof( SpecializationInfo ) ); } SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SpecializationInfo) ); + memcpy( this, &rhs, sizeof( SpecializationInfo ) ); return *this; } - SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ ) { mapEntryCount = mapEntryCount_; @@ -3898,15 +3948,14 @@ namespace vk ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) { - memcpy( this, &rhs, sizeof(ClearDepthStencilValue) ); + memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); } ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) { - memcpy( this, &rhs, sizeof(ClearDepthStencilValue) ); + memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); return *this; } - ClearDepthStencilValue& setDepth( float depth_ ) { depth = depth_; @@ -4041,15 +4090,14 @@ namespace vk PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); } PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); return *this; } - PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ ) { robustBufferAccess = robustBufferAccess_; @@ -4548,15 +4596,14 @@ namespace vk DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DrawIndirectCommand) ); + memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); } DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DrawIndirectCommand) ); + memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); return *this; } - DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ ) { vertexCount = vertexCount_; @@ -4619,15 +4666,14 @@ namespace vk DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DrawIndexedIndirectCommand) ); + memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); } DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DrawIndexedIndirectCommand) ); + memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); return *this; } - DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ ) { indexCount = indexCount_; @@ -4696,15 +4742,14 @@ namespace vk DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DispatchIndirectCommand) ); + memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); } DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DispatchIndirectCommand) ); + memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); return *this; } - DispatchIndirectCommand& setX( uint32_t x_ ) { x = x_; @@ -4779,15 +4824,14 @@ namespace vk DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayModeParametersKHR) ); + memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); } DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayModeParametersKHR) ); + memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); return *this; } - DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ ) { visibleRegion = visibleRegion_; @@ -4855,15 +4899,14 @@ namespace vk RectLayerKHR( VkRectLayerKHR const & rhs ) { - memcpy( this, &rhs, sizeof(RectLayerKHR) ); + memcpy( this, &rhs, sizeof( RectLayerKHR ) ); } RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) { - memcpy( this, &rhs, sizeof(RectLayerKHR) ); + memcpy( this, &rhs, sizeof( RectLayerKHR ) ); return *this; } - RectLayerKHR& setOffset( Offset2D offset_ ) { offset = offset_; @@ -4915,15 +4958,14 @@ namespace vk PresentRegionKHR( VkPresentRegionKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentRegionKHR) ); + memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); } PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentRegionKHR) ); + memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); return *this; } - PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ ) { rectangleCount = rectangleCount_; @@ -4967,15 +5009,14 @@ namespace vk XYColorEXT( VkXYColorEXT const & rhs ) { - memcpy( this, &rhs, sizeof(XYColorEXT) ); + memcpy( this, &rhs, sizeof( XYColorEXT ) ); } XYColorEXT& operator=( VkXYColorEXT const & rhs ) { - memcpy( this, &rhs, sizeof(XYColorEXT) ); + memcpy( this, &rhs, sizeof( XYColorEXT ) ); return *this; } - XYColorEXT& setX( float x_ ) { x = x_; @@ -5018,15 +5059,14 @@ namespace vk RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(RefreshCycleDurationGOOGLE) ); + memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); } RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(RefreshCycleDurationGOOGLE) ); + memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); return *this; } - RefreshCycleDurationGOOGLE& setRefreshDuration( uint64_t refreshDuration_ ) { refreshDuration = refreshDuration_; @@ -5065,15 +5105,14 @@ namespace vk PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PastPresentationTimingGOOGLE) ); + memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); } PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PastPresentationTimingGOOGLE) ); + memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); return *this; } - PastPresentationTimingGOOGLE& setPresentID( uint32_t presentID_ ) { presentID = presentID_; @@ -5141,15 +5180,14 @@ namespace vk PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PresentTimeGOOGLE) ); + memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); } PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PresentTimeGOOGLE) ); + memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); return *this; } - PresentTimeGOOGLE& setPresentID( uint32_t presentID_ ) { presentID = presentID_; @@ -5193,15 +5231,14 @@ namespace vk ViewportWScalingNV( VkViewportWScalingNV const & rhs ) { - memcpy( this, &rhs, sizeof(ViewportWScalingNV) ); + memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); } ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) { - memcpy( this, &rhs, sizeof(ViewportWScalingNV) ); + memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); return *this; } - ViewportWScalingNV& setXcoeff( float xcoeff_ ) { xcoeff = xcoeff_; @@ -5260,15 +5297,14 @@ namespace vk DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorImageInfo) ); + memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); } DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorImageInfo) ); + memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); return *this; } - DescriptorImageInfo& setSampler( Sampler sampler_ ) { sampler = sampler_; @@ -5320,15 +5356,14 @@ namespace vk AttachmentReference( VkAttachmentReference const & rhs ) { - memcpy( this, &rhs, sizeof(AttachmentReference) ); + memcpy( this, &rhs, sizeof( AttachmentReference ) ); } AttachmentReference& operator=( VkAttachmentReference const & rhs ) { - memcpy( this, &rhs, sizeof(AttachmentReference) ); + memcpy( this, &rhs, sizeof( AttachmentReference ) ); return *this; } - AttachmentReference& setAttachment( uint32_t attachment_ ) { attachment = attachment_; @@ -5428,15 +5463,14 @@ namespace vk ComponentMapping( VkComponentMapping const & rhs ) { - memcpy( this, &rhs, sizeof(ComponentMapping) ); + memcpy( this, &rhs, sizeof( ComponentMapping ) ); } ComponentMapping& operator=( VkComponentMapping const & rhs ) { - memcpy( this, &rhs, sizeof(ComponentMapping) ); + memcpy( this, &rhs, sizeof( ComponentMapping ) ); return *this; } - ComponentMapping& setR( ComponentSwizzle r_ ) { r = r_; @@ -5511,15 +5545,14 @@ namespace vk DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorPoolSize) ); + memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); } DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorPoolSize) ); + memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); return *this; } - DescriptorPoolSize& setType( DescriptorType type_ ) { type = type_; @@ -5567,15 +5600,14 @@ namespace vk DescriptorUpdateTemplateEntryKHR( VkDescriptorUpdateTemplateEntryKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateEntryKHR) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) ); } DescriptorUpdateTemplateEntryKHR& operator=( VkDescriptorUpdateTemplateEntryKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateEntryKHR) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) ); return *this; } - DescriptorUpdateTemplateEntryKHR& setDstBinding( uint32_t dstBinding_ ) { dstBinding = dstBinding_; @@ -5830,15 +5862,14 @@ namespace vk StencilOpState( VkStencilOpState const & rhs ) { - memcpy( this, &rhs, sizeof(StencilOpState) ); + memcpy( this, &rhs, sizeof( StencilOpState ) ); } StencilOpState& operator=( VkStencilOpState const & rhs ) { - memcpy( this, &rhs, sizeof(StencilOpState) ); + memcpy( this, &rhs, sizeof( StencilOpState ) ); return *this; } - StencilOpState& setFailOp( StencilOp failOp_ ) { failOp = failOp_; @@ -5972,15 +6003,14 @@ namespace vk VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) { - memcpy( this, &rhs, sizeof(VertexInputBindingDescription) ); + memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); } VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) { - memcpy( this, &rhs, sizeof(VertexInputBindingDescription) ); + memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); return *this; } - VertexInputBindingDescription& setBinding( uint32_t binding_ ) { binding = binding_; @@ -6231,15 +6261,14 @@ namespace vk VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) { - memcpy( this, &rhs, sizeof(VertexInputAttributeDescription) ); + memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); } VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) { - memcpy( this, &rhs, sizeof(VertexInputAttributeDescription) ); + memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); return *this; } - VertexInputAttributeDescription& setLocation( uint32_t location_ ) { location = location_; @@ -6454,15 +6483,14 @@ namespace vk ApplicationInfo( VkApplicationInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ApplicationInfo) ); + memcpy( this, &rhs, sizeof( ApplicationInfo ) ); } ApplicationInfo& operator=( VkApplicationInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ApplicationInfo) ); + memcpy( this, &rhs, sizeof( ApplicationInfo ) ); return *this; } - ApplicationInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6547,15 +6575,14 @@ namespace vk DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceQueueCreateInfo) ); + memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); } DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceQueueCreateInfo) ); + memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); return *this; } - DeviceQueueCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6636,15 +6663,14 @@ namespace vk DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceCreateInfo) ); + memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); } DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceCreateInfo) ); + memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); return *this; } - DeviceCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6755,15 +6781,14 @@ namespace vk InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(InstanceCreateInfo) ); + memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); } InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(InstanceCreateInfo) ); + memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); return *this; } - InstanceCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6854,15 +6879,14 @@ namespace vk MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryAllocateInfo) ); + memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); } MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryAllocateInfo) ); + memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); return *this; } - MemoryAllocateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6922,15 +6946,14 @@ namespace vk MappedMemoryRange( VkMappedMemoryRange const & rhs ) { - memcpy( this, &rhs, sizeof(MappedMemoryRange) ); + memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); } MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) { - memcpy( this, &rhs, sizeof(MappedMemoryRange) ); + memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); return *this; } - MappedMemoryRange& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7003,15 +7026,14 @@ namespace vk WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) { - memcpy( this, &rhs, sizeof(WriteDescriptorSet) ); + memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); } WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) { - memcpy( this, &rhs, sizeof(WriteDescriptorSet) ); + memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); return *this; } - WriteDescriptorSet& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7123,15 +7145,14 @@ namespace vk CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) { - memcpy( this, &rhs, sizeof(CopyDescriptorSet) ); + memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); } CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) { - memcpy( this, &rhs, sizeof(CopyDescriptorSet) ); + memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); return *this; } - CopyDescriptorSet& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7233,15 +7254,14 @@ namespace vk BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BufferViewCreateInfo) ); + memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); } BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BufferViewCreateInfo) ); + memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); return *this; } - BufferViewCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7325,15 +7345,14 @@ namespace vk ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ShaderModuleCreateInfo) ); + memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); } ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ShaderModuleCreateInfo) ); + memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); return *this; } - ShaderModuleCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7401,15 +7420,14 @@ namespace vk DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetAllocateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); } DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetAllocateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); return *this; } - DescriptorSetAllocateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7479,15 +7497,14 @@ namespace vk PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineVertexInputStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); } PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineVertexInputStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); return *this; } - PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7571,15 +7588,14 @@ namespace vk PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineInputAssemblyStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); } PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineInputAssemblyStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); return *this; } - PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7646,15 +7662,14 @@ namespace vk PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineTessellationStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); } PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineTessellationStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); return *this; } - PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7716,15 +7731,14 @@ namespace vk PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); } PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); return *this; } - PipelineViewportStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7816,15 +7830,14 @@ namespace vk PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineRasterizationStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); } PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineRasterizationStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); return *this; } - PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7963,15 +7976,14 @@ namespace vk PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDepthStencilStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); } PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDepthStencilStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); return *this; } - PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8095,15 +8107,14 @@ namespace vk PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineCacheCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); } PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineCacheCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); return *this; } - PipelineCacheCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8184,15 +8195,14 @@ namespace vk SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SamplerCreateInfo) ); + memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); } SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SamplerCreateInfo) ); + memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); return *this; } - SamplerCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8364,15 +8374,14 @@ namespace vk CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferAllocateInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); } CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferAllocateInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); return *this; } - CommandBufferAllocateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8442,15 +8451,14 @@ namespace vk RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassBeginInfo) ); + memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); } RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassBeginInfo) ); + memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); return *this; } - RenderPassBeginInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8532,15 +8540,14 @@ namespace vk EventCreateInfo( VkEventCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(EventCreateInfo) ); + memcpy( this, &rhs, sizeof( EventCreateInfo ) ); } EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(EventCreateInfo) ); + memcpy( this, &rhs, sizeof( EventCreateInfo ) ); return *this; } - EventCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8590,15 +8597,14 @@ namespace vk SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SemaphoreCreateInfo) ); + memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); } SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SemaphoreCreateInfo) ); + memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); return *this; } - SemaphoreCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8654,15 +8660,14 @@ namespace vk FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(FramebufferCreateInfo) ); + memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); } FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(FramebufferCreateInfo) ); + memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); return *this; } - FramebufferCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8761,15 +8766,14 @@ namespace vk DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayModeCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); } DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayModeCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); return *this; } - DisplayModeCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8829,15 +8833,14 @@ namespace vk DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayPresentInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); } DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayPresentInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); return *this; } - DisplayPresentInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8905,15 +8908,14 @@ namespace vk AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(AndroidSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); } AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(AndroidSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); return *this; } - AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8975,15 +8977,14 @@ namespace vk MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(MirSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); } MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(MirSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); return *this; } - MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9052,15 +9053,14 @@ namespace vk ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) { - memcpy( this, &rhs, sizeof(ViSurfaceCreateInfoNN) ); + memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); } ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) { - memcpy( this, &rhs, sizeof(ViSurfaceCreateInfoNN) ); + memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); return *this; } - ViSurfaceCreateInfoNN& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9122,15 +9122,14 @@ namespace vk WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(WaylandSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); } WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(WaylandSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); return *this; } - WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9200,15 +9199,14 @@ namespace vk Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(Win32SurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); } Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(Win32SurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); return *this; } - Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9278,15 +9276,14 @@ namespace vk XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(XlibSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); } XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(XlibSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); return *this; } - XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9356,15 +9353,14 @@ namespace vk XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(XcbSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); } XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(XcbSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); return *this; } - XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9432,15 +9428,14 @@ namespace vk DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerMarkerInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); } DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerMarkerInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); return *this; } - DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9498,15 +9493,14 @@ namespace vk DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationImageCreateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); } DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationImageCreateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); return *this; } - DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9556,15 +9550,14 @@ namespace vk DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationBufferCreateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); } DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationBufferCreateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); return *this; } - DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9615,15 +9608,14 @@ namespace vk DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationMemoryAllocateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); } DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationMemoryAllocateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); return *this; } - DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9683,15 +9675,14 @@ namespace vk ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); } ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); return *this; } - ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9757,15 +9748,14 @@ namespace vk Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); } Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); return *this; } - Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9864,15 +9854,14 @@ namespace vk DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsFeaturesNVX) ); + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); } DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsFeaturesNVX) ); + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); return *this; } - DeviceGeneratedCommandsFeaturesNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9926,15 +9915,14 @@ namespace vk DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsLimitsNVX) ); + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); } DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsLimitsNVX) ); + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); return *this; } - DeviceGeneratedCommandsLimitsNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10018,15 +10006,14 @@ namespace vk CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(CmdReserveSpaceForCommandsInfoNVX) ); + memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); } CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(CmdReserveSpaceForCommandsInfoNVX) ); + memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); return *this; } - CmdReserveSpaceForCommandsInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10092,15 +10079,14 @@ namespace vk PhysicalDeviceFeatures2KHR( VkPhysicalDeviceFeatures2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) ); } PhysicalDeviceFeatures2KHR& operator=( VkPhysicalDeviceFeatures2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) ); return *this; } - PhysicalDeviceFeatures2KHR& setPNext( void* pNext_ ) { pNext = pNext_; @@ -10150,15 +10136,14 @@ namespace vk PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDevicePushDescriptorPropertiesKHR) ); + memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); } PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDevicePushDescriptorPropertiesKHR) ); + memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); return *this; } - PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ ) { pNext = pNext_; @@ -10209,15 +10194,14 @@ namespace vk PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentRegionsKHR) ); + memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); } PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentRegionsKHR) ); + memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); return *this; } - PresentRegionsKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10312,15 +10296,14 @@ namespace vk ExportMemoryWin32HandleInfoKHX( VkExportMemoryWin32HandleInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHX ) ); } ExportMemoryWin32HandleInfoKHX& operator=( VkExportMemoryWin32HandleInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHX ) ); return *this; } - ExportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10452,15 +10435,14 @@ namespace vk Win32KeyedMutexAcquireReleaseInfoKHX( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoKHX) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) ); } Win32KeyedMutexAcquireReleaseInfoKHX& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoKHX) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) ); return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10562,15 +10544,14 @@ namespace vk ExportSemaphoreWin32HandleInfoKHX( VkExportSemaphoreWin32HandleInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExportSemaphoreWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHX ) ); } ExportSemaphoreWin32HandleInfoKHX& operator=( VkExportSemaphoreWin32HandleInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExportSemaphoreWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHX ) ); return *this; } - ExportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10641,15 +10622,14 @@ namespace vk D3D12FenceSubmitInfoKHX( VkD3D12FenceSubmitInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(D3D12FenceSubmitInfoKHX) ); + memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHX ) ); } D3D12FenceSubmitInfoKHX& operator=( VkD3D12FenceSubmitInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(D3D12FenceSubmitInfoKHX) ); + memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHX ) ); return *this; } - D3D12FenceSubmitInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10726,15 +10706,14 @@ namespace vk PhysicalDeviceMultiviewFeaturesKHX( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceMultiviewFeaturesKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) ); } PhysicalDeviceMultiviewFeaturesKHX& operator=( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceMultiviewFeaturesKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) ); return *this; } - PhysicalDeviceMultiviewFeaturesKHX& setPNext( void* pNext_ ) { pNext = pNext_; @@ -10835,15 +10814,14 @@ namespace vk RenderPassMultiviewCreateInfoKHX( VkRenderPassMultiviewCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassMultiviewCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) ); } RenderPassMultiviewCreateInfoKHX& operator=( VkRenderPassMultiviewCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassMultiviewCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) ); return *this; } - RenderPassMultiviewCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10937,15 +10915,14 @@ namespace vk BindBufferMemoryInfoKHX( VkBindBufferMemoryInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindBufferMemoryInfoKHX) ); + memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHX ) ); } BindBufferMemoryInfoKHX& operator=( VkBindBufferMemoryInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindBufferMemoryInfoKHX) ); + memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHX ) ); return *this; } - BindBufferMemoryInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11033,15 +11010,14 @@ namespace vk BindImageMemoryInfoKHX( VkBindImageMemoryInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindImageMemoryInfoKHX) ); + memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHX ) ); } BindImageMemoryInfoKHX& operator=( VkBindImageMemoryInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindImageMemoryInfoKHX) ); + memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHX ) ); return *this; } - BindImageMemoryInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11141,15 +11117,14 @@ namespace vk DeviceGroupRenderPassBeginInfoKHX( VkDeviceGroupRenderPassBeginInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupRenderPassBeginInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) ); } DeviceGroupRenderPassBeginInfoKHX& operator=( VkDeviceGroupRenderPassBeginInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupRenderPassBeginInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) ); return *this; } - DeviceGroupRenderPassBeginInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11215,15 +11190,14 @@ namespace vk DeviceGroupCommandBufferBeginInfoKHX( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupCommandBufferBeginInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) ); } DeviceGroupCommandBufferBeginInfoKHX& operator=( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupCommandBufferBeginInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) ); return *this; } - DeviceGroupCommandBufferBeginInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11278,15 +11252,14 @@ namespace vk DeviceGroupSubmitInfoKHX( VkDeviceGroupSubmitInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupSubmitInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) ); } DeviceGroupSubmitInfoKHX& operator=( VkDeviceGroupSubmitInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupSubmitInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) ); return *this; } - DeviceGroupSubmitInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11377,15 +11350,14 @@ namespace vk DeviceGroupBindSparseInfoKHX( VkDeviceGroupBindSparseInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupBindSparseInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) ); } DeviceGroupBindSparseInfoKHX& operator=( VkDeviceGroupBindSparseInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupBindSparseInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) ); return *this; } - DeviceGroupBindSparseInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11443,15 +11415,14 @@ namespace vk ImageSwapchainCreateInfoKHX( VkImageSwapchainCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSwapchainCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) ); } ImageSwapchainCreateInfoKHX& operator=( VkImageSwapchainCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSwapchainCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) ); return *this; } - ImageSwapchainCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11502,15 +11473,14 @@ namespace vk BindImageMemorySwapchainInfoKHX( VkBindImageMemorySwapchainInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindImageMemorySwapchainInfoKHX) ); + memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) ); } BindImageMemorySwapchainInfoKHX& operator=( VkBindImageMemorySwapchainInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindImageMemorySwapchainInfoKHX) ); + memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) ); return *this; } - BindImageMemorySwapchainInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11572,15 +11542,14 @@ namespace vk AcquireNextImageInfoKHX( VkAcquireNextImageInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(AcquireNextImageInfoKHX) ); + memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) ); } AcquireNextImageInfoKHX& operator=( VkAcquireNextImageInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(AcquireNextImageInfoKHX) ); + memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) ); return *this; } - AcquireNextImageInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11669,15 +11638,14 @@ namespace vk HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) { - memcpy( this, &rhs, sizeof(HdrMetadataEXT) ); + memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); } HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) { - memcpy( this, &rhs, sizeof(HdrMetadataEXT) ); + memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); return *this; } - HdrMetadataEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11784,15 +11752,14 @@ namespace vk PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PresentTimesInfoGOOGLE) ); + memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); } PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PresentTimesInfoGOOGLE) ); + memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); return *this; } - PresentTimesInfoGOOGLE& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11852,15 +11819,14 @@ namespace vk IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) { - memcpy( this, &rhs, sizeof(IOSSurfaceCreateInfoMVK) ); + memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); } IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) { - memcpy( this, &rhs, sizeof(IOSSurfaceCreateInfoMVK) ); + memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); return *this; } - IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11921,15 +11887,14 @@ namespace vk MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) { - memcpy( this, &rhs, sizeof(MacOSSurfaceCreateInfoMVK) ); + memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); } MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) { - memcpy( this, &rhs, sizeof(MacOSSurfaceCreateInfoMVK) ); + memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); return *this; } - MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11990,15 +11955,14 @@ namespace vk PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportWScalingStateCreateInfoNV) ); + memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); } PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportWScalingStateCreateInfoNV) ); + memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); return *this; } - PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12064,15 +12028,14 @@ namespace vk PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceDiscardRectanglePropertiesEXT) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); } PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceDiscardRectanglePropertiesEXT) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); return *this; } - PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( void* pNext_ ) { pNext = pNext_; @@ -12161,15 +12124,14 @@ namespace vk PresentInfoKHR( VkPresentInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentInfoKHR) ); + memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); } PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentInfoKHR) ); + memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); return *this; } - PresentInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12276,15 +12238,14 @@ namespace vk PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); } PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); return *this; } - PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12363,15 +12324,14 @@ namespace vk DescriptorUpdateTemplateCreateInfoKHR( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); } DescriptorUpdateTemplateCreateInfoKHR& operator=( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); return *this; } - DescriptorUpdateTemplateCreateInfoKHR& setPNext( void* pNext_ ) { pNext = pNext_; @@ -12760,15 +12720,14 @@ namespace vk MemoryBarrier( VkMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryBarrier) ); + memcpy( this, &rhs, sizeof( MemoryBarrier ) ); } MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryBarrier) ); + memcpy( this, &rhs, sizeof( MemoryBarrier ) ); return *this; } - MemoryBarrier& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12832,15 +12791,14 @@ namespace vk BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(BufferMemoryBarrier) ); + memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); } BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(BufferMemoryBarrier) ); + memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); return *this; } - BufferMemoryBarrier& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13003,15 +12961,14 @@ namespace vk BufferCreateInfo( VkBufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BufferCreateInfo) ); + memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); } BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BufferCreateInfo) ); + memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); return *this; } - BufferCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13135,15 +13092,14 @@ namespace vk DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); } DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); return *this; } - DescriptorSetLayoutBinding& setBinding( uint32_t binding_ ) { binding = binding_; @@ -13216,15 +13172,14 @@ namespace vk PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); } PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); return *this; } - PipelineShaderStageCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13306,15 +13261,14 @@ namespace vk PushConstantRange( VkPushConstantRange const & rhs ) { - memcpy( this, &rhs, sizeof(PushConstantRange) ); + memcpy( this, &rhs, sizeof( PushConstantRange ) ); } PushConstantRange& operator=( VkPushConstantRange const & rhs ) { - memcpy( this, &rhs, sizeof(PushConstantRange) ); + memcpy( this, &rhs, sizeof( PushConstantRange ) ); return *this; } - PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ ) { stageFlags = stageFlags_; @@ -13371,15 +13325,14 @@ namespace vk PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); } PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); return *this; } - PipelineLayoutCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13528,15 +13481,14 @@ namespace vk PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); } PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); return *this; } - PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13651,15 +13603,14 @@ namespace vk ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) ); + memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); } ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) ); + memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); return *this; } - ComputePipelineCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13774,15 +13725,14 @@ namespace vk PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); } PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); return *this; } - PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ ) { blendEnable = blendEnable_; @@ -13880,15 +13830,14 @@ namespace vk PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); } PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); return *this; } - PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14003,15 +13952,14 @@ namespace vk FenceCreateInfo( VkFenceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(FenceCreateInfo) ); + memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); } FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(FenceCreateInfo) ); + memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); return *this; } - FenceCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14274,15 +14222,14 @@ namespace vk CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); } CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); return *this; } - CommandBufferInheritanceInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14373,15 +14320,14 @@ namespace vk CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); } CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); return *this; } - CommandBufferBeginInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14442,15 +14388,14 @@ namespace vk QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); } QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); return *this; } - QueryPoolCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14552,15 +14497,14 @@ namespace vk ImageSubresource( VkImageSubresource const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresource) ); + memcpy( this, &rhs, sizeof( ImageSubresource ) ); } ImageSubresource& operator=( VkImageSubresource const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresource) ); + memcpy( this, &rhs, sizeof( ImageSubresource ) ); return *this; } - ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ ) { aspectMask = aspectMask_; @@ -14614,15 +14558,14 @@ namespace vk ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresourceLayers) ); + memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); } ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresourceLayers) ); + memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); return *this; } - ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ ) { aspectMask = aspectMask_; @@ -14685,15 +14628,14 @@ namespace vk ImageSubresourceRange( VkImageSubresourceRange const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresourceRange) ); + memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); } ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresourceRange) ); + memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); return *this; } - ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ ) { aspectMask = aspectMask_; @@ -14769,15 +14711,14 @@ namespace vk ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(ImageMemoryBarrier) ); + memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); } ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(ImageMemoryBarrier) ); + memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); return *this; } - ImageMemoryBarrier& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14888,15 +14829,14 @@ namespace vk ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ImageViewCreateInfo) ); + memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); } ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ImageViewCreateInfo) ); + memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); return *this; } - ImageViewCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14988,15 +14928,14 @@ namespace vk ImageCopy( VkImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof(ImageCopy) ); + memcpy( this, &rhs, sizeof( ImageCopy ) ); } ImageCopy& operator=( VkImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof(ImageCopy) ); + memcpy( this, &rhs, sizeof( ImageCopy ) ); return *this; } - ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { srcSubresource = srcSubresource_; @@ -15066,15 +15005,14 @@ namespace vk ImageBlit( VkImageBlit const & rhs ) { - memcpy( this, &rhs, sizeof(ImageBlit) ); + memcpy( this, &rhs, sizeof( ImageBlit ) ); } ImageBlit& operator=( VkImageBlit const & rhs ) { - memcpy( this, &rhs, sizeof(ImageBlit) ); + memcpy( this, &rhs, sizeof( ImageBlit ) ); return *this; } - ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { srcSubresource = srcSubresource_; @@ -15138,15 +15076,14 @@ namespace vk BufferImageCopy( VkBufferImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof(BufferImageCopy) ); + memcpy( this, &rhs, sizeof( BufferImageCopy ) ); } BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof(BufferImageCopy) ); + memcpy( this, &rhs, sizeof( BufferImageCopy ) ); return *this; } - BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ ) { bufferOffset = bufferOffset_; @@ -15225,15 +15162,14 @@ namespace vk ImageResolve( VkImageResolve const & rhs ) { - memcpy( this, &rhs, sizeof(ImageResolve) ); + memcpy( this, &rhs, sizeof( ImageResolve ) ); } ImageResolve& operator=( VkImageResolve const & rhs ) { - memcpy( this, &rhs, sizeof(ImageResolve) ); + memcpy( this, &rhs, sizeof( ImageResolve ) ); return *this; } - ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { srcSubresource = srcSubresource_; @@ -15302,15 +15238,14 @@ namespace vk ClearAttachment( VkClearAttachment const & rhs ) { - memcpy( this, &rhs, sizeof(ClearAttachment) ); + memcpy( this, &rhs, sizeof( ClearAttachment ) ); } ClearAttachment& operator=( VkClearAttachment const & rhs ) { - memcpy( this, &rhs, sizeof(ClearAttachment) ); + memcpy( this, &rhs, sizeof( ClearAttachment ) ); return *this; } - ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ ) { aspectMask = aspectMask_; @@ -15487,15 +15422,14 @@ namespace vk SparseMemoryBind( VkSparseMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof(SparseMemoryBind) ); + memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); } SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof(SparseMemoryBind) ); + memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); return *this; } - SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ ) { resourceOffset = resourceOffset_; @@ -15567,15 +15501,14 @@ namespace vk SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageMemoryBind) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); } SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageMemoryBind) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); return *this; } - SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ ) { subresource = subresource_; @@ -15652,15 +15585,14 @@ namespace vk SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); } SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); return *this; } - SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ ) { buffer = buffer_; @@ -15713,15 +15645,14 @@ namespace vk SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); } SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); return *this; } - SparseImageOpaqueMemoryBindInfo& setImage( Image image_ ) { image = image_; @@ -15774,15 +15705,14 @@ namespace vk SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); } SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); return *this; } - SparseImageMemoryBindInfo& setImage( Image image_ ) { image = image_; @@ -15844,15 +15774,14 @@ namespace vk BindSparseInfo( VkBindSparseInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BindSparseInfo) ); + memcpy( this, &rhs, sizeof( BindSparseInfo ) ); } BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BindSparseInfo) ); + memcpy( this, &rhs, sizeof( BindSparseInfo ) ); return *this; } - BindSparseInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -16043,15 +15972,14 @@ namespace vk CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); } CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); return *this; } - CommandPoolCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -16231,15 +16159,14 @@ namespace vk ImageCreateInfo( VkImageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ImageCreateInfo) ); + memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); } ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ImageCreateInfo) ); + memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); return *this; } - ImageCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -16391,15 +16318,14 @@ namespace vk PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); } PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); return *this; } - PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -16513,15 +16439,14 @@ namespace vk GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) ); + memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); } GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) ); + memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); return *this; } - GraphicsPipelineCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -17027,15 +16952,14 @@ namespace vk PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); } PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); return *this; } - PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -17148,15 +17072,14 @@ namespace vk AttachmentDescription( VkAttachmentDescription const & rhs ) { - memcpy( this, &rhs, sizeof(AttachmentDescription) ); + memcpy( this, &rhs, sizeof( AttachmentDescription ) ); } AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) { - memcpy( this, &rhs, sizeof(AttachmentDescription) ); + memcpy( this, &rhs, sizeof( AttachmentDescription ) ); return *this; } - AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ ) { flags = flags_; @@ -17312,15 +17235,14 @@ namespace vk DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); } DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); return *this; } - DescriptorPoolCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -17425,15 +17347,14 @@ namespace vk SubpassDependency( VkSubpassDependency const & rhs ) { - memcpy( this, &rhs, sizeof(SubpassDependency) ); + memcpy( this, &rhs, sizeof( SubpassDependency ) ); } SubpassDependency& operator=( VkSubpassDependency const & rhs ) { - memcpy( this, &rhs, sizeof(SubpassDependency) ); + memcpy( this, &rhs, sizeof( SubpassDependency ) ); return *this; } - SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ ) { srcSubpass = srcSubpass_; @@ -17733,15 +17654,14 @@ namespace vk DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); } DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); return *this; } - DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -17917,15 +17837,14 @@ namespace vk DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); } DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); return *this; } - DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18031,15 +17950,14 @@ namespace vk DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); } DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); return *this; } - DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18109,15 +18027,14 @@ namespace vk DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); } DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); return *this; } - DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18211,15 +18128,14 @@ namespace vk PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); } PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); return *this; } - PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18297,15 +18213,14 @@ namespace vk ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); } ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); return *this; } - ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18355,15 +18270,14 @@ namespace vk ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); } ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); return *this; } - ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18415,15 +18329,14 @@ namespace vk ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); } ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); return *this; } - ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18542,15 +18455,14 @@ namespace vk ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) { - memcpy( this, &rhs, sizeof(ValidationFlagsEXT) ); + memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); } ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) { - memcpy( this, &rhs, sizeof(ValidationFlagsEXT) ); + memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); return *this; } - ValidationFlagsEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18674,15 +18586,14 @@ namespace vk IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); } IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); return *this; } - IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) { tokenType = tokenType_; @@ -18736,15 +18647,14 @@ namespace vk IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); } IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); return *this; } - IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) { tokenType = tokenType_; @@ -18808,15 +18718,14 @@ namespace vk IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); } IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); return *this; } - IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18907,15 +18816,14 @@ namespace vk ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); } ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); return *this; } - ObjectTableCreateInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19028,15 +18936,14 @@ namespace vk ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); } ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); return *this; } - ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19081,15 +18988,14 @@ namespace vk ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); } ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); return *this; } - ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19143,15 +19049,14 @@ namespace vk ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); } ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); return *this; } - ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19212,15 +19117,14 @@ namespace vk ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); } ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); return *this; } - ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19274,15 +19178,14 @@ namespace vk ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); } ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); return *this; } - ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19344,15 +19247,14 @@ namespace vk ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); } ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); return *this; } - ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19440,15 +19342,14 @@ namespace vk DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); } DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); return *this; } - DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19545,15 +19446,14 @@ namespace vk PhysicalDeviceExternalImageFormatInfoKHX( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalImageFormatInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) ); } PhysicalDeviceExternalImageFormatInfoKHX& operator=( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalImageFormatInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) ); return *this; } - PhysicalDeviceExternalImageFormatInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19605,15 +19505,14 @@ namespace vk PhysicalDeviceExternalBufferInfoKHX( VkPhysicalDeviceExternalBufferInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalBufferInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHX ) ); } PhysicalDeviceExternalBufferInfoKHX& operator=( VkPhysicalDeviceExternalBufferInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalBufferInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHX ) ); return *this; } - PhysicalDeviceExternalBufferInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19679,15 +19578,14 @@ namespace vk ExternalMemoryImageCreateInfoKHX( VkExternalMemoryImageCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHX ) ); } ExternalMemoryImageCreateInfoKHX& operator=( VkExternalMemoryImageCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHX ) ); return *this; } - ExternalMemoryImageCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19737,15 +19635,14 @@ namespace vk ExternalMemoryBufferCreateInfoKHX( VkExternalMemoryBufferCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryBufferCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHX ) ); } ExternalMemoryBufferCreateInfoKHX& operator=( VkExternalMemoryBufferCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryBufferCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHX ) ); return *this; } - ExternalMemoryBufferCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19795,15 +19692,14 @@ namespace vk ExportMemoryAllocateInfoKHX( VkExportMemoryAllocateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHX ) ); } ExportMemoryAllocateInfoKHX& operator=( VkExportMemoryAllocateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHX ) ); return *this; } - ExportMemoryAllocateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19855,15 +19751,14 @@ namespace vk ImportMemoryWin32HandleInfoKHX( VkImportMemoryWin32HandleInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHX ) ); } ImportMemoryWin32HandleInfoKHX& operator=( VkImportMemoryWin32HandleInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHX ) ); return *this; } - ImportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19923,15 +19818,14 @@ namespace vk ImportMemoryFdInfoKHX( VkImportMemoryFdInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryFdInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHX ) ); } ImportMemoryFdInfoKHX& operator=( VkImportMemoryFdInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryFdInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHX ) ); return *this; } - ImportMemoryFdInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20126,15 +20020,14 @@ namespace vk PhysicalDeviceExternalSemaphoreInfoKHX( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalSemaphoreInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) ); } PhysicalDeviceExternalSemaphoreInfoKHX& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalSemaphoreInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) ); return *this; } - PhysicalDeviceExternalSemaphoreInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20184,15 +20077,14 @@ namespace vk ExportSemaphoreCreateInfoKHX( VkExportSemaphoreCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExportSemaphoreCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHX ) ); } ExportSemaphoreCreateInfoKHX& operator=( VkExportSemaphoreCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ExportSemaphoreCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHX ) ); return *this; } - ExportSemaphoreCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20245,15 +20137,14 @@ namespace vk ImportSemaphoreWin32HandleInfoKHX( VkImportSemaphoreWin32HandleInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImportSemaphoreWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHX ) ); } ImportSemaphoreWin32HandleInfoKHX& operator=( VkImportSemaphoreWin32HandleInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImportSemaphoreWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHX ) ); return *this; } - ImportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20322,15 +20213,14 @@ namespace vk ImportSemaphoreFdInfoKHX( VkImportSemaphoreFdInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImportSemaphoreFdInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHX ) ); } ImportSemaphoreFdInfoKHX& operator=( VkImportSemaphoreFdInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImportSemaphoreFdInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHX ) ); return *this; } - ImportSemaphoreFdInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20527,15 +20417,14 @@ namespace vk SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); } SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); return *this; } - SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20592,15 +20481,14 @@ namespace vk DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) ); + memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); } DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) ); + memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); return *this; } - DisplayPowerInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20655,15 +20543,14 @@ namespace vk DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) ); + memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); } DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) ); + memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); return *this; } - DeviceEventInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20718,15 +20605,14 @@ namespace vk DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) ); + memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); } DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) ); + memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); return *this; } - DisplayEventInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20830,15 +20716,14 @@ namespace vk MemoryAllocateFlagsInfoKHX( VkMemoryAllocateFlagsInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryAllocateFlagsInfoKHX) ); + memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) ); } MemoryAllocateFlagsInfoKHX& operator=( VkMemoryAllocateFlagsInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryAllocateFlagsInfoKHX) ); + memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) ); return *this; } - MemoryAllocateFlagsInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20956,15 +20841,14 @@ namespace vk DeviceGroupPresentInfoKHX( VkDeviceGroupPresentInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupPresentInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) ); } DeviceGroupPresentInfoKHX& operator=( VkDeviceGroupPresentInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupPresentInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) ); return *this; } - DeviceGroupPresentInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21030,15 +20914,14 @@ namespace vk DeviceGroupSwapchainCreateInfoKHX( VkDeviceGroupSwapchainCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupSwapchainCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) ); } DeviceGroupSwapchainCreateInfoKHX& operator=( VkDeviceGroupSwapchainCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupSwapchainCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) ); return *this; } - DeviceGroupSwapchainCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21128,15 +21011,14 @@ namespace vk SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); } SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); return *this; } - SwapchainCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21319,15 +21201,14 @@ namespace vk ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) { - memcpy( this, &rhs, sizeof(ViewportSwizzleNV) ); + memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); } ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) { - memcpy( this, &rhs, sizeof(ViewportSwizzleNV) ); + memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); return *this; } - ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ ) { x = x_; @@ -21390,15 +21271,14 @@ namespace vk PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportSwizzleStateCreateInfoNV) ); + memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); } PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportSwizzleStateCreateInfoNV) ); + memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); return *this; } - PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21473,15 +21353,14 @@ namespace vk PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDiscardRectangleStateCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); } PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDiscardRectangleStateCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); return *this; } - PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21588,15 +21467,14 @@ namespace vk SubpassDescription( VkSubpassDescription const & rhs ) { - memcpy( this, &rhs, sizeof(SubpassDescription) ); + memcpy( this, &rhs, sizeof( SubpassDescription ) ); } SubpassDescription& operator=( VkSubpassDescription const & rhs ) { - memcpy( this, &rhs, sizeof(SubpassDescription) ); + memcpy( this, &rhs, sizeof( SubpassDescription ) ); return *this; } - SubpassDescription& setFlags( SubpassDescriptionFlags flags_ ) { flags = flags_; @@ -21711,15 +21589,14 @@ namespace vk RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassCreateInfo) ); + memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); } RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassCreateInfo) ); + memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); return *this; } - RenderPassCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21886,35 +21763,35 @@ namespace vk : m_commandBuffer(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer(VkCommandBuffer commandBuffer) - : m_commandBuffer(commandBuffer) + VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) + : m_commandBuffer( commandBuffer ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - CommandBuffer& operator=(VkCommandBuffer commandBuffer) + CommandBuffer & operator=(VkCommandBuffer commandBuffer) { m_commandBuffer = commandBuffer; - return *this; + return *this; } #endif - CommandBuffer& operator=( std::nullptr_t ) + CommandBuffer & operator=( std::nullptr_t ) { m_commandBuffer = VK_NULL_HANDLE; return *this; } - bool operator==(CommandBuffer const &rhs) const + bool operator==( CommandBuffer const & rhs ) const { return m_commandBuffer == rhs.m_commandBuffer; } - bool operator!=(CommandBuffer const &rhs) const + bool operator!=(CommandBuffer const & rhs ) const { return m_commandBuffer != rhs.m_commandBuffer; } - bool operator<(CommandBuffer const &rhs) const + bool operator<(CommandBuffer const & rhs ) const { return m_commandBuffer < rhs.m_commandBuffer; } @@ -22130,6 +22007,8 @@ namespace vk void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy discardRectangles ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const { return m_commandBuffer; @@ -22148,6 +22027,7 @@ namespace vk private: VkCommandBuffer m_commandBuffer; }; + static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo ) const @@ -22660,15 +22540,14 @@ namespace vk SubmitInfo( VkSubmitInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SubmitInfo) ); + memcpy( this, &rhs, sizeof( SubmitInfo ) ); } SubmitInfo& operator=( VkSubmitInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SubmitInfo) ); + memcpy( this, &rhs, sizeof( SubmitInfo ) ); return *this; } - SubmitInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -22766,35 +22645,35 @@ namespace vk : m_queue(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Queue(VkQueue queue) - : m_queue(queue) + VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) + : m_queue( queue ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Queue& operator=(VkQueue queue) + Queue & operator=(VkQueue queue) { m_queue = queue; - return *this; + return *this; } #endif - Queue& operator=( std::nullptr_t ) + Queue & operator=( std::nullptr_t ) { m_queue = VK_NULL_HANDLE; return *this; } - bool operator==(Queue const &rhs) const + bool operator==( Queue const & rhs ) const { return m_queue == rhs.m_queue; } - bool operator!=(Queue const &rhs) const + bool operator!=(Queue const & rhs ) const { return m_queue != rhs.m_queue; } - bool operator<(Queue const &rhs) const + bool operator<(Queue const & rhs ) const { return m_queue < rhs.m_queue; } @@ -22820,6 +22699,8 @@ namespace vk Result presentKHR( const PresentInfoKHR & presentInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const { return m_queue; @@ -22838,6 +22719,7 @@ namespace vk private: VkQueue m_queue; }; + static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) const @@ -22953,35 +22835,35 @@ namespace vk : m_device(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Device(VkDevice device) - : m_device(device) + VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) + : m_device( device ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Device& operator=(VkDevice device) + Device & operator=(VkDevice device) { m_device = device; - return *this; + return *this; } #endif - Device& operator=( std::nullptr_t ) + Device & operator=( std::nullptr_t ) { m_device = VK_NULL_HANDLE; return *this; } - bool operator==(Device const &rhs) const + bool operator==( Device const & rhs ) const { return m_device == rhs.m_device; } - bool operator!=(Device const &rhs) const + bool operator!=(Device const & rhs ) const { return m_device != rhs.m_device; } - bool operator<(Device const &rhs) const + bool operator<(Device const & rhs ) const { return m_device < rhs.m_device; } @@ -23644,6 +23526,8 @@ namespace vk typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const { return m_device; @@ -23662,6 +23546,7 @@ namespace vk private: VkDevice m_device; }; + static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); #ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -25807,35 +25692,35 @@ namespace vk : m_physicalDevice(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice(VkPhysicalDevice physicalDevice) - : m_physicalDevice(physicalDevice) + VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) + : m_physicalDevice( physicalDevice ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PhysicalDevice& operator=(VkPhysicalDevice physicalDevice) + PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) { m_physicalDevice = physicalDevice; - return *this; + return *this; } #endif - PhysicalDevice& operator=( std::nullptr_t ) + PhysicalDevice & operator=( std::nullptr_t ) { m_physicalDevice = VK_NULL_HANDLE; return *this; } - bool operator==(PhysicalDevice const &rhs) const + bool operator==( PhysicalDevice const & rhs ) const { return m_physicalDevice == rhs.m_physicalDevice; } - bool operator!=(PhysicalDevice const &rhs) const + bool operator!=(PhysicalDevice const & rhs ) const { return m_physicalDevice != rhs.m_physicalDevice; } - bool operator<(PhysicalDevice const &rhs) const + bool operator<(PhysicalDevice const & rhs ) const { return m_physicalDevice < rhs.m_physicalDevice; } @@ -26073,6 +25958,8 @@ namespace vk typename ResultValueType>::type getPresentRectanglesKHX( SurfaceKHR surface ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const { return m_physicalDevice; @@ -26091,6 +25978,7 @@ namespace vk private: VkPhysicalDevice m_physicalDevice; }; + static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); #ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -26802,15 +26690,14 @@ namespace vk CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) ); + memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); } CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) ); + memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); return *this; } - CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -26971,35 +26858,35 @@ namespace vk : m_instance(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Instance(VkInstance instance) - : m_instance(instance) + VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) + : m_instance( instance ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Instance& operator=(VkInstance instance) + Instance & operator=(VkInstance instance) { m_instance = instance; - return *this; + return *this; } #endif - Instance& operator=( std::nullptr_t ) + Instance & operator=( std::nullptr_t ) { m_instance = VK_NULL_HANDLE; return *this; } - bool operator==(Instance const &rhs) const + bool operator==( Instance const & rhs ) const { return m_instance == rhs.m_instance; } - bool operator!=(Instance const &rhs) const + bool operator!=(Instance const & rhs ) const { return m_instance != rhs.m_instance; } - bool operator<(Instance const &rhs) const + bool operator<(Instance const & rhs ) const { return m_instance < rhs.m_instance; } @@ -27147,6 +27034,8 @@ namespace vk #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const { return m_instance; @@ -27165,6 +27054,7 @@ namespace vk private: VkInstance m_instance; }; + static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); #ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -27570,15 +27460,14 @@ namespace vk DeviceGroupDeviceCreateInfoKHX( VkDeviceGroupDeviceCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupDeviceCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) ); } DeviceGroupDeviceCreateInfoKHX& operator=( VkDeviceGroupDeviceCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupDeviceCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) ); return *this; } - DeviceGroupDeviceCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_;