diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index e587750..9a7b21e 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -61,6 +61,8 @@ std::vector tokenize(std::string tokenString, char separator); std::string trim(std::string const& input); std::string trimEnd(std::string const& input); +const std::set nonConstSTypeStructs = { "VkBaseInStructure", "VkBaseOutStructure" }; + void appendArgumentCount(std::string & str, size_t vectorIndex, std::string const& vectorName, std::string const& counterName, size_t returnParamIndex, size_t templateParamIndex, bool twoStep, bool singular) { // this parameter is a count parameter for a vector parameter @@ -2531,7 +2533,7 @@ void VulkanHppGenerator::appendStructCompareOperators(std::string & str, std::pa str += replaceWithMap(compareTemplate, { { "name", stripPrefix(structData.first, "Vk") }, { "compareMembers", compareMembers } }); } -std::string VulkanHppGenerator::appendStructConstructor(std::pair const& structData, std::string const& prefix, bool withLayoutStructure) const +std::string VulkanHppGenerator::appendStructConstructor(std::pair const& structData, std::string const& prefix) const { // the constructor with all the elements as arguments, with defaults // returnedOnly structs and structs with a union (and VkBaseInStructure and VkBaseOutStructure) can't be a constexpr! @@ -2543,95 +2545,86 @@ std::string VulkanHppGenerator::appendStructConstructor(std::pair::copy( " + member.name + ", " + member.name + "_ );\n"; - } + std::string type = (member.type.type.substr(0, 2) == "Vk") ? ("vk::" + stripPrefix(member.type.type, "Vk")) : member.type.type; + copyOps += prefix + " vk::ConstExpressionArrayCopy<" + type + "," + member.arraySize + "," + member.arraySize + ">::copy( " + member.name + ", " + member.name + "_ );\n"; } } } std::string structConstructor = ctorOpening + (arguments.empty() ? "()" : std::string("( " + arguments + " )")) + " VULKAN_HPP_NOEXCEPT\n"; - if (withLayoutStructure) + structConstructor += initializers; + if (copyOps.empty()) { - structConstructor += prefix + " : layout::" + stripPrefix(structData.first, "Vk") + (initializers.empty() ? "()" : std::string("( " + initializers + " )")) + "\n" + prefix + "{}\n"; + structConstructor += prefix + "{}\n"; } else { - structConstructor += initializers; - if (copyOps.empty()) + structConstructor += prefix + "{\n" + copyOps + prefix + "}\n"; + } + + if (!structData.second.subStruct.empty()) + { + auto const& subStruct = m_structures.find(structData.second.subStruct); + assert(subStruct != m_structures.end()); + + std::string subStructArgumentName = startLowerCase(stripPrefix(subStruct->first, "Vk")); + ctorOpening = prefix + "explicit " + stripPrefix(structData.first, "Vk") + "( "; + indentation = std::string(ctorOpening.size(), ' '); + + std::string subCopies; + firstArgument = true; + for (size_t i = 0; i < subStruct->second.members.size(); i++) { - structConstructor += prefix + "{}\n"; - } - else - { - structConstructor += prefix + "{\n" + copyOps + prefix + "}\n"; + assert(structData.second.members[i].arraySize.empty()); + subCopies += prefix + " " + (firstArgument ? ":" : ",") + " " + structData.second.members[i].name + "( " + subStructArgumentName + "." + subStruct->second.members[i].name + " )\n"; + firstArgument = false; } - if (!structData.second.subStruct.empty()) + std::string subArguments; + listedArgument = true; + for (size_t i = subStruct->second.members.size(); i < structData.second.members.size(); i++) { - auto const& subStruct = m_structures.find(structData.second.subStruct); - assert(subStruct != m_structures.end()); + listedArgument = appendStructConstructorArgument(subArguments, listedArgument, indentation, structData.second.members[i]); - std::string subStructArgumentName = startLowerCase(stripPrefix(subStruct->first, "Vk")); - ctorOpening = prefix + "explicit " + stripPrefix(structData.first, "Vk") + "( "; - indentation = std::string(ctorOpening.size(), ' '); - - std::string subCopies; - firstArgument = true; - for (size_t i = 0; i < subStruct->second.members.size(); i++) - { - assert(structData.second.members[i].arraySize.empty()); - subCopies += prefix + " " + (firstArgument ? ":" : ",") + " " + structData.second.members[i].name + "( " + subStructArgumentName + "." + subStruct->second.members[i].name + " )\n"; - firstArgument = false; - } - - std::string subArguments; - listedArgument = true; - for (size_t i = subStruct->second.members.size(); i < structData.second.members.size(); i++) - { - listedArgument = appendStructConstructorArgument(subArguments, listedArgument, indentation, structData.second.members[i]); - - assert(structData.second.members[i].arraySize.empty()); - subCopies += prefix + " , " + structData.second.members[i].name + "( " + structData.second.members[i].name + "_ )\n"; - } - - structConstructor += "\n" - " explicit " + stripPrefix(structData.first, "Vk") + "( " + stripPrefix(subStruct->first, "Vk") + " const& " + subStructArgumentName + subArguments + " )\n" - + subCopies + - " {}\n"; + assert(structData.second.members[i].arraySize.empty()); + subCopies += prefix + " , " + structData.second.members[i].name + "( " + structData.second.members[i].name + "_ )\n"; } + + structConstructor += "\n" + " explicit " + stripPrefix(structData.first, "Vk") + "( " + stripPrefix(subStruct->first, "Vk") + " const& " + subStructArgumentName + subArguments + " )\n" + + subCopies + + " {}\n"; + } + + // we need a copy constructor if there is constant sType in this struct + if ((nonConstSTypeStructs.find(structData.first) == nonConstSTypeStructs.end()) && !structData.second.members.empty() && (structData.second.members.front().name == "sType")) + { + structConstructor += "\n" + prefix + "vk::" + stripPrefix(structData.first, "Vk") + " & operator=( vk::" + stripPrefix(structData.first, "Vk") + " const & rhs ) VULKAN_HPP_NOEXCEPT\n"; + structConstructor += prefix + "{\n"; + assert((2 <= structData.second.members.size()) && (structData.second.members[1].name == "pNext")); + structConstructor += prefix + " memcpy( &pNext, &rhs.pNext, sizeof( vk::" + stripPrefix(structData.first, "Vk") + " ) - sizeof( vk::StructureType ) );\n"; + structConstructor += prefix + " return *this;\n"; + structConstructor += prefix + "}\n"; } return structConstructor; @@ -2656,40 +2649,34 @@ bool VulkanHppGenerator::appendStructConstructorArgument(std::string & str, bool return listedArgument; } -void VulkanHppGenerator::appendStructCopyConstructors(std::string & str, std::string const& name, bool withLayoutStructure) const +void VulkanHppGenerator::appendStructCopyConstructors(std::string & str, std::string const& name) const { static const std::string templateString = R"( ${name}( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ${name}& operator=( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; - return *this; - } -)"; - static const std::string layoutTemplateString = R"( - ${name}( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::${name}( rhs ) - {} - - ${name}& operator=( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT - { - layout::${name}::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } )"; - str += replaceWithMap(withLayoutStructure ? layoutTemplateString : templateString, { { "name", name } }); + str += replaceWithMap(templateString, { { "name", name } }); } -void VulkanHppGenerator::appendStructMembers(std::string & str, StructureData const& structData, std::string const& prefix) const +void VulkanHppGenerator::appendStructMembers(std::string & str, std::pair const& structData, std::string const& prefix) const { - for (auto const& member : structData.members) + for (auto const& member : structData.second.members) { - str += prefix + member.type.compose() + " " + member.name; + str += prefix; + if ((member.name == "sType") && (nonConstSTypeStructs.find(structData.first) == nonConstSTypeStructs.end())) // special handling for sType and some nasty little structs that don't get a const sType + { + str += "const "; + } + str += member.type.compose() + " " + member.name; if (member.name == "sType") // special handling for sType { auto enumIt = m_enums.find("VkStructureType"); @@ -2753,49 +2740,8 @@ void VulkanHppGenerator::appendStructure(std::string & str, std::pair(this) = rhs; - } - - ${name}& operator=( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: -${members} }; - static_assert( sizeof( ${name} ) == sizeof( Vk${name} ), "layout struct and wrapper have different size!" ); - } -)"; - - std::string members; - appendStructMembers(members, structure.second, " "); - - str += replaceWithMap(layoutStructureTemplate, - { - { "name", stripPrefix(structure.first, "Vk") }, - { "constructor", appendStructConstructor(structure, " ", false)}, - { "members", members} - }); - } - - std::string constructorAndSetters = appendStructConstructor(structure, " ", withLayoutStructure); - appendStructCopyConstructors(constructorAndSetters, stripPrefix(structure.first, "Vk"), withLayoutStructure); + std::string constructorAndSetters = appendStructConstructor(structure, " "); + appendStructCopyConstructors(constructorAndSetters, stripPrefix(structure.first, "Vk")); if (!structure.second.returnedOnly) { // only structs that are not returnedOnly get setters! @@ -2814,20 +2760,11 @@ ${members} }; } // the member variables - std::string members; - if (withLayoutStructure) - { - // hide sType when a layout structure is used to keep standard_layout - members = "\n private:\n using layout::" + stripPrefix(structure.first, "Vk") + "::sType;\n"; - } - else - { - members = "\n public:\n"; - appendStructMembers(members, structure.second, " "); - } + std::string members = "\n public:\n"; + appendStructMembers(members, structure, " "); static const std::string structureTemplate = R"( - struct ${name}${baseClass} + struct ${name} { ${constructorAndSetters} @@ -2852,7 +2789,6 @@ ${members} str += replaceWithMap(structureTemplate, { { "name", stripPrefix(structure.first, "Vk") }, - { "baseClass", baseClass }, { "constructorAndSetters", constructorAndSetters }, { "vkName", structure.first }, { "compareOperators", compareOperators }, diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index 2edc7d6..af3a279 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -194,10 +194,10 @@ class VulkanHppGenerator void appendPlatformLeave(std::string & str, std::string const& platform) const; void appendStruct(std::string & str, std::pair const& structure, std::set & listedStructures) const; void appendStructCompareOperators(std::string & str, std::pair const& structure) const; - std::string appendStructConstructor(std::pair const& structData, std::string const& prefix, bool withLayoutStructure) const; + std::string appendStructConstructor(std::pair const& structData, std::string const& prefix) const; bool appendStructConstructorArgument(std::string & str, bool listedArgument, std::string const& indentation, MemberData const& memberData) const; - void appendStructCopyConstructors(std::string & str, std::string const& vkName, bool withLayoutStructure) const; - void appendStructMembers(std::string & str, StructureData const& structData, std::string const& prefix) const; + void appendStructCopyConstructors(std::string & str, std::string const& vkName) const; + void appendStructMembers(std::string & str, std::pair const& structData, std::string const& prefix) const; void appendStructSetter(std::string & str, std::string const& structureName, MemberData const& memberData) const; void appendStructure(std::string & str, std::pair const& structure) const; void appendUnion(std::string & str, std::pair const& structure) const; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 85e7394..36a04e4 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -19287,65 +19287,7 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType::type enumerateInstanceVersion(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - namespace layout - { - struct GeometryTrianglesNV - { - protected: - VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(), - vk::DeviceSize vertexOffset_ = 0, - uint32_t vertexCount_ = 0, - vk::DeviceSize vertexStride_ = 0, - vk::Format vertexFormat_ = vk::Format::eUndefined, - vk::Buffer indexData_ = vk::Buffer(), - vk::DeviceSize indexOffset_ = 0, - uint32_t indexCount_ = 0, - vk::IndexType indexType_ = vk::IndexType::eUint16, - vk::Buffer transformData_ = vk::Buffer(), - vk::DeviceSize transformOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : vertexData( vertexData_ ) - , vertexOffset( vertexOffset_ ) - , vertexCount( vertexCount_ ) - , vertexStride( vertexStride_ ) - , vertexFormat( vertexFormat_ ) - , indexData( indexData_ ) - , indexOffset( indexOffset_ ) - , indexCount( indexCount_ ) - , indexType( indexType_ ) - , transformData( transformData_ ) - , transformOffset( transformOffset_ ) - {} - - GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eGeometryTrianglesNV; - const void* pNext = nullptr; - vk::Buffer vertexData; - vk::DeviceSize vertexOffset; - uint32_t vertexCount; - vk::DeviceSize vertexStride; - vk::Format vertexFormat; - vk::Buffer indexData; - vk::DeviceSize indexOffset; - uint32_t indexCount; - vk::IndexType indexType; - vk::Buffer transformData; - vk::DeviceSize transformOffset; - }; - static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "layout struct and wrapper have different size!" ); - } - - struct GeometryTrianglesNV : public layout::GeometryTrianglesNV + struct GeometryTrianglesNV { VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(), vk::DeviceSize vertexOffset_ = 0, @@ -19358,16 +19300,33 @@ namespace VULKAN_HPP_NAMESPACE vk::IndexType indexType_ = vk::IndexType::eUint16, vk::Buffer transformData_ = vk::Buffer(), vk::DeviceSize transformOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::GeometryTrianglesNV( vertexData_, vertexOffset_, vertexCount_, vertexStride_, vertexFormat_, indexData_, indexOffset_, indexCount_, indexType_, transformData_, transformOffset_ ) + : vertexData( vertexData_ ) + , vertexOffset( vertexOffset_ ) + , vertexCount( vertexCount_ ) + , vertexStride( vertexStride_ ) + , vertexFormat( vertexFormat_ ) + , indexData( indexData_ ) + , indexOffset( indexOffset_ ) + , indexCount( indexCount_ ) + , indexType( indexType_ ) + , transformData( transformData_ ) + , transformOffset( transformOffset_ ) {} + vk::GeometryTrianglesNV & operator=( vk::GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryTrianglesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::GeometryTrianglesNV( rhs ) - {} + { + *this = rhs; + } GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::GeometryTrianglesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19475,65 +19434,50 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::GeometryTrianglesNV::sType; + public: + const vk::StructureType sType = StructureType::eGeometryTrianglesNV; + const void* pNext = nullptr; + vk::Buffer vertexData; + vk::DeviceSize vertexOffset; + uint32_t vertexCount; + vk::DeviceSize vertexStride; + vk::Format vertexFormat; + vk::Buffer indexData; + vk::DeviceSize indexOffset; + uint32_t indexCount; + vk::IndexType indexType; + vk::Buffer transformData; + vk::DeviceSize transformOffset; }; static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct GeometryAABBNV - { - protected: - VULKAN_HPP_CONSTEXPR GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(), - uint32_t numAABBs_ = 0, - uint32_t stride_ = 0, - vk::DeviceSize offset_ = 0 ) VULKAN_HPP_NOEXCEPT - : aabbData( aabbData_ ) - , numAABBs( numAABBs_ ) - , stride( stride_ ) - , offset( offset_ ) - {} - - GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eGeometryAabbNV; - const void* pNext = nullptr; - vk::Buffer aabbData; - uint32_t numAABBs; - uint32_t stride; - vk::DeviceSize offset; - }; - static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "layout struct and wrapper have different size!" ); - } - - struct GeometryAABBNV : public layout::GeometryAABBNV + struct GeometryAABBNV { VULKAN_HPP_CONSTEXPR GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(), uint32_t numAABBs_ = 0, uint32_t stride_ = 0, vk::DeviceSize offset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::GeometryAABBNV( aabbData_, numAABBs_, stride_, offset_ ) + : aabbData( aabbData_ ) + , numAABBs( numAABBs_ ) + , stride( stride_ ) + , offset( offset_ ) {} + vk::GeometryAABBNV & operator=( vk::GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryAABBNV ) - sizeof( vk::StructureType ) ); + return *this; + } + GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::GeometryAABBNV( rhs ) - {} + { + *this = rhs; + } GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::GeometryAABBNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19592,8 +19536,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::GeometryAABBNV::sType; + public: + const vk::StructureType sType = StructureType::eGeometryAabbNV; + const void* pNext = nullptr; + vk::Buffer aabbData; + uint32_t numAABBs; + uint32_t stride; + vk::DeviceSize offset; }; static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -19608,12 +19557,12 @@ namespace VULKAN_HPP_NAMESPACE GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } GeometryDataNV& operator=( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -19657,55 +19606,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct GeometryNV - { - protected: - VULKAN_HPP_CONSTEXPR GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles, - vk::GeometryDataNV geometry_ = vk::GeometryDataNV(), - vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() ) VULKAN_HPP_NOEXCEPT - : geometryType( geometryType_ ) - , geometry( geometry_ ) - , flags( flags_ ) - {} - - GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - GeometryNV& operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eGeometryNV; - const void* pNext = nullptr; - vk::GeometryTypeNV geometryType; - vk::GeometryDataNV geometry; - vk::GeometryFlagsNV flags; - }; - static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "layout struct and wrapper have different size!" ); - } - - struct GeometryNV : public layout::GeometryNV + struct GeometryNV { VULKAN_HPP_CONSTEXPR GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles, vk::GeometryDataNV geometry_ = vk::GeometryDataNV(), vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() ) VULKAN_HPP_NOEXCEPT - : layout::GeometryNV( geometryType_, geometry_, flags_ ) + : geometryType( geometryType_ ) + , geometry( geometry_ ) + , flags( flags_ ) {} + vk::GeometryNV & operator=( vk::GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryNV ) - sizeof( vk::StructureType ) ); + return *this; + } + GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::GeometryNV( rhs ) - {} + { + *this = rhs; + } GeometryNV& operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::GeometryNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19757,69 +19681,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::GeometryNV::sType; + public: + const vk::StructureType sType = StructureType::eGeometryNV; + const void* pNext = nullptr; + vk::GeometryTypeNV geometryType; + vk::GeometryDataNV geometry; + vk::GeometryFlagsNV flags; }; static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AccelerationStructureInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( vk::AccelerationStructureTypeNV type_ = vk::AccelerationStructureTypeNV::eTopLevel, - vk::BuildAccelerationStructureFlagsNV flags_ = vk::BuildAccelerationStructureFlagsNV(), - uint32_t instanceCount_ = 0, - uint32_t geometryCount_ = 0, - const vk::GeometryNV* pGeometries_ = nullptr ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - , flags( flags_ ) - , instanceCount( instanceCount_ ) - , geometryCount( geometryCount_ ) - , pGeometries( pGeometries_ ) - {} - - AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAccelerationStructureInfoNV; - const void* pNext = nullptr; - vk::AccelerationStructureTypeNV type; - vk::BuildAccelerationStructureFlagsNV flags; - uint32_t instanceCount; - uint32_t geometryCount; - const vk::GeometryNV* pGeometries; - }; - static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct AccelerationStructureInfoNV : public layout::AccelerationStructureInfoNV + struct AccelerationStructureInfoNV { VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( vk::AccelerationStructureTypeNV type_ = vk::AccelerationStructureTypeNV::eTopLevel, vk::BuildAccelerationStructureFlagsNV flags_ = vk::BuildAccelerationStructureFlagsNV(), uint32_t instanceCount_ = 0, uint32_t geometryCount_ = 0, const vk::GeometryNV* pGeometries_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureInfoNV( type_, flags_, instanceCount_, geometryCount_, pGeometries_ ) + : type( type_ ) + , flags( flags_ ) + , instanceCount( instanceCount_ ) + , geometryCount( geometryCount_ ) + , pGeometries( pGeometries_ ) {} + vk::AccelerationStructureInfoNV & operator=( vk::AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureInfoNV( rhs ) - {} + { + *this = rhs; + } AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AccelerationStructureInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19885,57 +19784,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AccelerationStructureInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eAccelerationStructureInfoNV; + const void* pNext = nullptr; + vk::AccelerationStructureTypeNV type; + vk::BuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + const vk::GeometryNV* pGeometries; }; static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AccelerationStructureCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0, - vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() ) VULKAN_HPP_NOEXCEPT - : compactedSize( compactedSize_ ) - , info( info_ ) - {} - - AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; - const void* pNext = nullptr; - vk::DeviceSize compactedSize; - vk::AccelerationStructureInfoNV info; - }; - static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct AccelerationStructureCreateInfoNV : public layout::AccelerationStructureCreateInfoNV + struct AccelerationStructureCreateInfoNV { VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0, vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureCreateInfoNV( compactedSize_, info_ ) + : compactedSize( compactedSize_ ) + , info( info_ ) {} + vk::AccelerationStructureCreateInfoNV & operator=( vk::AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureCreateInfoNV( rhs ) - {} + { + *this = rhs; + } AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AccelerationStructureCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19980,57 +19862,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AccelerationStructureCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; + const void* pNext = nullptr; + vk::DeviceSize compactedSize; + vk::AccelerationStructureInfoNV info; }; static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AccelerationStructureMemoryRequirementsInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject, - vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - , accelerationStructure( accelerationStructure_ ) - {} - - AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; - const void* pNext = nullptr; - vk::AccelerationStructureMemoryRequirementsTypeNV type; - vk::AccelerationStructureNV accelerationStructure; - }; - static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct AccelerationStructureMemoryRequirementsInfoNV : public layout::AccelerationStructureMemoryRequirementsInfoNV + struct AccelerationStructureMemoryRequirementsInfoNV { VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject, vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureMemoryRequirementsInfoNV( type_, accelerationStructure_ ) + : type( type_ ) + , accelerationStructure( accelerationStructure_ ) {} + vk::AccelerationStructureMemoryRequirementsInfoNV & operator=( vk::AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureMemoryRequirementsInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureMemoryRequirementsInfoNV( rhs ) - {} + { + *this = rhs; + } AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AccelerationStructureMemoryRequirementsInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20075,69 +19937,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AccelerationStructureMemoryRequirementsInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; + const void* pNext = nullptr; + vk::AccelerationStructureMemoryRequirementsTypeNV type; + vk::AccelerationStructureNV accelerationStructure; }; static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AcquireNextImageInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(), - uint64_t timeout_ = 0, - vk::Semaphore semaphore_ = vk::Semaphore(), - vk::Fence fence_ = vk::Fence(), - uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : swapchain( swapchain_ ) - , timeout( timeout_ ) - , semaphore( semaphore_ ) - , fence( fence_ ) - , deviceMask( deviceMask_ ) - {} - - AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAcquireNextImageInfoKHR; - const void* pNext = nullptr; - vk::SwapchainKHR swapchain; - uint64_t timeout; - vk::Semaphore semaphore; - vk::Fence fence; - uint32_t deviceMask; - }; - static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct AcquireNextImageInfoKHR : public layout::AcquireNextImageInfoKHR + struct AcquireNextImageInfoKHR { VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(), uint64_t timeout_ = 0, vk::Semaphore semaphore_ = vk::Semaphore(), vk::Fence fence_ = vk::Fence(), uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::AcquireNextImageInfoKHR( swapchain_, timeout_, semaphore_, fence_, deviceMask_ ) + : swapchain( swapchain_ ) + , timeout( timeout_ ) + , semaphore( semaphore_ ) + , fence( fence_ ) + , deviceMask( deviceMask_ ) {} + vk::AcquireNextImageInfoKHR & operator=( vk::AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AcquireNextImageInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AcquireNextImageInfoKHR( rhs ) - {} + { + *this = rhs; + } AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AcquireNextImageInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20203,8 +20039,14 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AcquireNextImageInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eAcquireNextImageInfoKHR; + const void* pNext = nullptr; + vk::SwapchainKHR swapchain; + uint64_t timeout; + vk::Semaphore semaphore; + vk::Fence fence; + uint32_t deviceMask; }; static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -20227,12 +20069,12 @@ namespace VULKAN_HPP_NAMESPACE AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -20322,12 +20164,12 @@ namespace VULKAN_HPP_NAMESPACE ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ComponentMapping& operator=( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -20389,53 +20231,40 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout + struct AndroidHardwareBufferFormatPropertiesANDROID { - struct AndroidHardwareBufferFormatPropertiesANDROID - { - protected: - AndroidHardwareBufferFormatPropertiesANDROID() VULKAN_HPP_NOEXCEPT - {} - - AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; - void* pNext = nullptr; - vk::Format format; - uint64_t externalFormat; - vk::FormatFeatureFlags formatFeatures; - vk::ComponentMapping samplerYcbcrConversionComponents; - vk::SamplerYcbcrModelConversion suggestedYcbcrModel; - vk::SamplerYcbcrRange suggestedYcbcrRange; - vk::ChromaLocation suggestedXChromaOffset; - vk::ChromaLocation suggestedYChromaOffset; - }; - static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "layout struct and wrapper have different size!" ); - } - - struct AndroidHardwareBufferFormatPropertiesANDROID : public layout::AndroidHardwareBufferFormatPropertiesANDROID - { - AndroidHardwareBufferFormatPropertiesANDROID() VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferFormatPropertiesANDROID() + AndroidHardwareBufferFormatPropertiesANDROID( vk::Format format_ = vk::Format::eUndefined, + uint64_t externalFormat_ = 0, + vk::FormatFeatureFlags formatFeatures_ = vk::FormatFeatureFlags(), + vk::ComponentMapping samplerYcbcrConversionComponents_ = vk::ComponentMapping(), + vk::SamplerYcbcrModelConversion suggestedYcbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity, + vk::SamplerYcbcrRange suggestedYcbcrRange_ = vk::SamplerYcbcrRange::eItuFull, + vk::ChromaLocation suggestedXChromaOffset_ = vk::ChromaLocation::eCositedEven, + vk::ChromaLocation suggestedYChromaOffset_ = vk::ChromaLocation::eCositedEven ) VULKAN_HPP_NOEXCEPT + : format( format_ ) + , externalFormat( externalFormat_ ) + , formatFeatures( formatFeatures_ ) + , samplerYcbcrConversionComponents( samplerYcbcrConversionComponents_ ) + , suggestedYcbcrModel( suggestedYcbcrModel_ ) + , suggestedYcbcrRange( suggestedYcbcrRange_ ) + , suggestedXChromaOffset( suggestedXChromaOffset_ ) + , suggestedYChromaOffset( suggestedYChromaOffset_ ) {} + vk::AndroidHardwareBufferFormatPropertiesANDROID & operator=( vk::AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferFormatPropertiesANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferFormatPropertiesANDROID( rhs ) - {} + { + *this = rhs; + } AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AndroidHardwareBufferFormatPropertiesANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20468,8 +20297,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AndroidHardwareBufferFormatPropertiesANDROID::sType; + public: + const vk::StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; + void* pNext = nullptr; + vk::Format format; + uint64_t externalFormat; + vk::FormatFeatureFlags formatFeatures; + vk::ComponentMapping samplerYcbcrConversionComponents; + vk::SamplerYcbcrModelConversion suggestedYcbcrModel; + vk::SamplerYcbcrRange suggestedYcbcrRange; + vk::ChromaLocation suggestedXChromaOffset; + vk::ChromaLocation suggestedYChromaOffset; }; static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -20477,47 +20315,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout + struct AndroidHardwareBufferPropertiesANDROID { - struct AndroidHardwareBufferPropertiesANDROID - { - protected: - AndroidHardwareBufferPropertiesANDROID() VULKAN_HPP_NOEXCEPT - {} - - AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; - void* pNext = nullptr; - vk::DeviceSize allocationSize; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "layout struct and wrapper have different size!" ); - } - - struct AndroidHardwareBufferPropertiesANDROID : public layout::AndroidHardwareBufferPropertiesANDROID - { - AndroidHardwareBufferPropertiesANDROID() VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferPropertiesANDROID() + AndroidHardwareBufferPropertiesANDROID( vk::DeviceSize allocationSize_ = 0, + uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : allocationSize( allocationSize_ ) + , memoryTypeBits( memoryTypeBits_ ) {} + vk::AndroidHardwareBufferPropertiesANDROID & operator=( vk::AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferPropertiesANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferPropertiesANDROID( rhs ) - {} + { + *this = rhs; + } AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AndroidHardwareBufferPropertiesANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20544,8 +20363,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AndroidHardwareBufferPropertiesANDROID::sType; + public: + const vk::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; + void* pNext = nullptr; + vk::DeviceSize allocationSize; + uint32_t memoryTypeBits; }; static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -20553,46 +20375,26 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout + struct AndroidHardwareBufferUsageANDROID { - struct AndroidHardwareBufferUsageANDROID - { - protected: - AndroidHardwareBufferUsageANDROID() VULKAN_HPP_NOEXCEPT - {} - - AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; - void* pNext = nullptr; - uint64_t androidHardwareBufferUsage; - }; - static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "layout struct and wrapper have different size!" ); - } - - struct AndroidHardwareBufferUsageANDROID : public layout::AndroidHardwareBufferUsageANDROID - { - AndroidHardwareBufferUsageANDROID() VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferUsageANDROID() + AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = 0 ) VULKAN_HPP_NOEXCEPT + : androidHardwareBufferUsage( androidHardwareBufferUsage_ ) {} + vk::AndroidHardwareBufferUsageANDROID & operator=( vk::AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferUsageANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferUsageANDROID( rhs ) - {} + { + *this = rhs; + } AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AndroidHardwareBufferUsageANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20618,8 +20420,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AndroidHardwareBufferUsageANDROID::sType; + public: + const vk::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; + void* pNext = nullptr; + uint64_t androidHardwareBufferUsage; }; static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -20627,51 +20431,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout - { - struct AndroidSurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(), - struct ANativeWindow* window_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , window( window_ ) - {} - - AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::AndroidSurfaceCreateFlagsKHR flags; - struct ANativeWindow* window; - }; - static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct AndroidSurfaceCreateInfoKHR : public layout::AndroidSurfaceCreateInfoKHR + struct AndroidSurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(), struct ANativeWindow* window_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::AndroidSurfaceCreateInfoKHR( flags_, window_ ) + : flags( flags_ ) + , window( window_ ) {} + vk::AndroidSurfaceCreateInfoKHR & operator=( vk::AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AndroidSurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AndroidSurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20716,70 +20497,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AndroidSurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::AndroidSurfaceCreateFlagsKHR flags; + struct ANativeWindow* window; }; static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - namespace layout - { - struct ApplicationInfo - { - protected: - VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = nullptr, - uint32_t applicationVersion_ = 0, - const char* pEngineName_ = nullptr, - uint32_t engineVersion_ = 0, - uint32_t apiVersion_ = 0 ) VULKAN_HPP_NOEXCEPT - : pApplicationName( pApplicationName_ ) - , applicationVersion( applicationVersion_ ) - , pEngineName( pEngineName_ ) - , engineVersion( engineVersion_ ) - , apiVersion( apiVersion_ ) - {} - - ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ApplicationInfo& operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eApplicationInfo; - const void* pNext = nullptr; - const char* pApplicationName; - uint32_t applicationVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; - }; - static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "layout struct and wrapper have different size!" ); - } - - struct ApplicationInfo : public layout::ApplicationInfo + struct ApplicationInfo { VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ApplicationInfo( pApplicationName_, applicationVersion_, pEngineName_, engineVersion_, apiVersion_ ) + : pApplicationName( pApplicationName_ ) + , applicationVersion( applicationVersion_ ) + , pEngineName( pEngineName_ ) + , engineVersion( engineVersion_ ) + , apiVersion( apiVersion_ ) {} + vk::ApplicationInfo & operator=( vk::ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ApplicationInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ApplicationInfo( rhs ) - {} + { + *this = rhs; + } ApplicationInfo& operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ApplicationInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20845,8 +20600,14 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ApplicationInfo::sType; + public: + const vk::StructureType sType = StructureType::eApplicationInfo; + const void* pNext = nullptr; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; }; static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -20875,12 +20636,12 @@ namespace VULKAN_HPP_NAMESPACE AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -20980,59 +20741,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AttachmentDescription2KHR - { - protected: - VULKAN_HPP_CONSTEXPR AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(), - vk::Format format_ = vk::Format::eUndefined, - vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1, - vk::AttachmentLoadOp loadOp_ = vk::AttachmentLoadOp::eLoad, - vk::AttachmentStoreOp storeOp_ = vk::AttachmentStoreOp::eStore, - vk::AttachmentLoadOp stencilLoadOp_ = vk::AttachmentLoadOp::eLoad, - vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore, - vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined, - vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , format( format_ ) - , samples( samples_ ) - , loadOp( loadOp_ ) - , storeOp( storeOp_ ) - , stencilLoadOp( stencilLoadOp_ ) - , stencilStoreOp( stencilStoreOp_ ) - , initialLayout( initialLayout_ ) - , finalLayout( finalLayout_ ) - {} - - AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAttachmentDescription2KHR; - const void* pNext = nullptr; - vk::AttachmentDescriptionFlags flags; - vk::Format format; - vk::SampleCountFlagBits samples; - vk::AttachmentLoadOp loadOp; - vk::AttachmentStoreOp storeOp; - vk::AttachmentLoadOp stencilLoadOp; - vk::AttachmentStoreOp stencilStoreOp; - vk::ImageLayout initialLayout; - vk::ImageLayout finalLayout; - }; - static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "layout struct and wrapper have different size!" ); - } - - struct AttachmentDescription2KHR : public layout::AttachmentDescription2KHR + struct AttachmentDescription2KHR { VULKAN_HPP_CONSTEXPR AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(), vk::Format format_ = vk::Format::eUndefined, @@ -21043,16 +20752,31 @@ namespace VULKAN_HPP_NAMESPACE vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore, vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined, vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentDescription2KHR( flags_, format_, samples_, loadOp_, storeOp_, stencilLoadOp_, stencilStoreOp_, initialLayout_, finalLayout_ ) + : flags( flags_ ) + , format( format_ ) + , samples( samples_ ) + , loadOp( loadOp_ ) + , storeOp( storeOp_ ) + , stencilLoadOp( stencilLoadOp_ ) + , stencilStoreOp( stencilStoreOp_ ) + , initialLayout( initialLayout_ ) + , finalLayout( finalLayout_ ) {} + vk::AttachmentDescription2KHR & operator=( vk::AttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentDescription2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentDescription2KHR( rhs ) - {} + { + *this = rhs; + } AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AttachmentDescription2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21146,8 +20870,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AttachmentDescription2KHR::sType; + public: + const vk::StructureType sType = StructureType::eAttachmentDescription2KHR; + const void* pNext = nullptr; + vk::AttachmentDescriptionFlags flags; + vk::Format format; + vk::SampleCountFlagBits samples; + vk::AttachmentLoadOp loadOp; + vk::AttachmentStoreOp storeOp; + vk::AttachmentLoadOp stencilLoadOp; + vk::AttachmentStoreOp stencilStoreOp; + vk::ImageLayout initialLayout; + vk::ImageLayout finalLayout; }; static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -21162,12 +20896,12 @@ namespace VULKAN_HPP_NAMESPACE AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } AttachmentReference& operator=( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -21211,55 +20945,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AttachmentReference2KHR - { - protected: - VULKAN_HPP_CONSTEXPR AttachmentReference2KHR( uint32_t attachment_ = 0, - vk::ImageLayout layout_ = vk::ImageLayout::eUndefined, - vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() ) VULKAN_HPP_NOEXCEPT - : attachment( attachment_ ) - , layout( layout_ ) - , aspectMask( aspectMask_ ) - {} - - AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAttachmentReference2KHR; - const void* pNext = nullptr; - uint32_t attachment; - vk::ImageLayout layout; - vk::ImageAspectFlags aspectMask; - }; - static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "layout struct and wrapper have different size!" ); - } - - struct AttachmentReference2KHR : public layout::AttachmentReference2KHR + struct AttachmentReference2KHR { VULKAN_HPP_CONSTEXPR AttachmentReference2KHR( uint32_t attachment_ = 0, vk::ImageLayout layout_ = vk::ImageLayout::eUndefined, vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentReference2KHR( attachment_, layout_, aspectMask_ ) + : attachment( attachment_ ) + , layout( layout_ ) + , aspectMask( aspectMask_ ) {} + vk::AttachmentReference2KHR & operator=( vk::AttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentReference2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentReference2KHR( rhs ) - {} + { + *this = rhs; + } AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AttachmentReference2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21311,8 +21020,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AttachmentReference2KHR::sType; + public: + const vk::StructureType sType = StructureType::eAttachmentReference2KHR; + const void* pNext = nullptr; + uint32_t attachment; + vk::ImageLayout layout; + vk::ImageAspectFlags aspectMask; }; static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -21327,12 +21040,12 @@ namespace VULKAN_HPP_NAMESPACE Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Extent2D& operator=( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -21386,12 +21099,12 @@ namespace VULKAN_HPP_NAMESPACE SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -21435,59 +21148,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SampleLocationsInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1, - vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(), - uint32_t sampleLocationsCount_ = 0, - const vk::SampleLocationEXT* pSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT - : sampleLocationsPerPixel( sampleLocationsPerPixel_ ) - , sampleLocationGridSize( sampleLocationGridSize_ ) - , sampleLocationsCount( sampleLocationsCount_ ) - , pSampleLocations( pSampleLocations_ ) - {} - - SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSampleLocationsInfoEXT; - const void* pNext = nullptr; - vk::SampleCountFlagBits sampleLocationsPerPixel; - vk::Extent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const vk::SampleLocationEXT* pSampleLocations; - }; - static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SampleLocationsInfoEXT : public layout::SampleLocationsInfoEXT + struct SampleLocationsInfoEXT { VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1, vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(), uint32_t sampleLocationsCount_ = 0, const vk::SampleLocationEXT* pSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SampleLocationsInfoEXT( sampleLocationsPerPixel_, sampleLocationGridSize_, sampleLocationsCount_, pSampleLocations_ ) + : sampleLocationsPerPixel( sampleLocationsPerPixel_ ) + , sampleLocationGridSize( sampleLocationGridSize_ ) + , sampleLocationsCount( sampleLocationsCount_ ) + , pSampleLocations( pSampleLocations_ ) {} + vk::SampleLocationsInfoEXT & operator=( vk::SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SampleLocationsInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SampleLocationsInfoEXT( rhs ) - {} + { + *this = rhs; + } SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SampleLocationsInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21546,8 +21232,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SampleLocationsInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSampleLocationsInfoEXT; + const void* pNext = nullptr; + vk::SampleCountFlagBits sampleLocationsPerPixel; + vk::Extent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const vk::SampleLocationEXT* pSampleLocations; }; static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -21562,12 +21253,12 @@ namespace VULKAN_HPP_NAMESPACE AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -21611,45 +21302,19 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BaseInStructure - { - protected: - BaseInStructure() VULKAN_HPP_NOEXCEPT - {} - - BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BaseInStructure& operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType; - const struct vk::BaseInStructure* pNext = nullptr; - }; - static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "layout struct and wrapper have different size!" ); - } - - struct BaseInStructure : public layout::BaseInStructure + struct BaseInStructure { BaseInStructure() VULKAN_HPP_NOEXCEPT - : layout::BaseInStructure() {} BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BaseInStructure( rhs ) - {} + { + *this = rhs; + } BaseInStructure& operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BaseInStructure::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21680,51 +21345,26 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BaseInStructure::sType; + public: + vk::StructureType sType; + const struct vk::BaseInStructure* pNext = nullptr; }; static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BaseOutStructure - { - protected: - BaseOutStructure() VULKAN_HPP_NOEXCEPT - {} - - BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType; - struct vk::BaseOutStructure* pNext = nullptr; - }; - static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "layout struct and wrapper have different size!" ); - } - - struct BaseOutStructure : public layout::BaseOutStructure + struct BaseOutStructure { BaseOutStructure() VULKAN_HPP_NOEXCEPT - : layout::BaseOutStructure() {} BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BaseOutStructure( rhs ) - {} + { + *this = rhs; + } BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BaseOutStructure::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21755,69 +21395,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BaseOutStructure::sType; + public: + vk::StructureType sType; + struct vk::BaseOutStructure* pNext = nullptr; }; static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindAccelerationStructureMemoryInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(), - vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::DeviceSize memoryOffset_ = 0, - uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : accelerationStructure( accelerationStructure_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - {} - - BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV; - const void* pNext = nullptr; - vk::AccelerationStructureNV accelerationStructure; - vk::DeviceMemory memory; - vk::DeviceSize memoryOffset; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - }; - static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct BindAccelerationStructureMemoryInfoNV : public layout::BindAccelerationStructureMemoryInfoNV + struct BindAccelerationStructureMemoryInfoNV { VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(), vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::DeviceSize memoryOffset_ = 0, uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BindAccelerationStructureMemoryInfoNV( accelerationStructure_, memory_, memoryOffset_, deviceIndexCount_, pDeviceIndices_ ) + : accelerationStructure( accelerationStructure_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + , deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) {} + vk::BindAccelerationStructureMemoryInfoNV & operator=( vk::BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindAccelerationStructureMemoryInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindAccelerationStructureMemoryInfoNV( rhs ) - {} + { + *this = rhs; + } BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindAccelerationStructureMemoryInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21883,57 +21495,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindAccelerationStructureMemoryInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV; + const void* pNext = nullptr; + vk::AccelerationStructureNV accelerationStructure; + vk::DeviceMemory memory; + vk::DeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; }; static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindBufferMemoryDeviceGroupInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - {} - - BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; - const void* pNext = nullptr; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - }; - static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindBufferMemoryDeviceGroupInfo : public layout::BindBufferMemoryDeviceGroupInfo + struct BindBufferMemoryDeviceGroupInfo { VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BindBufferMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_ ) + : deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) {} + vk::BindBufferMemoryDeviceGroupInfo & operator=( vk::BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindBufferMemoryDeviceGroupInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindBufferMemoryDeviceGroupInfo( rhs ) - {} + { + *this = rhs; + } BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindBufferMemoryDeviceGroupInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21978,61 +21573,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindBufferMemoryDeviceGroupInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; + const void* pNext = nullptr; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; }; static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindBufferMemoryInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(), - vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - {} - - BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindBufferMemoryInfo; - const void* pNext = nullptr; - vk::Buffer buffer; - vk::DeviceMemory memory; - vk::DeviceSize memoryOffset; - }; - static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindBufferMemoryInfo : public layout::BindBufferMemoryInfo + struct BindBufferMemoryInfo { VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(), vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BindBufferMemoryInfo( buffer_, memory_, memoryOffset_ ) + : buffer( buffer_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) {} + vk::BindBufferMemoryInfo & operator=( vk::BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindBufferMemoryInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindBufferMemoryInfo( rhs ) - {} + { + *this = rhs; + } BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindBufferMemoryInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22084,8 +21657,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindBufferMemoryInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindBufferMemoryInfo; + const void* pNext = nullptr; + vk::Buffer buffer; + vk::DeviceMemory memory; + vk::DeviceSize memoryOffset; }; static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -22100,12 +21677,12 @@ namespace VULKAN_HPP_NAMESPACE Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Offset2D& operator=( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22159,12 +21736,12 @@ namespace VULKAN_HPP_NAMESPACE Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Rect2D& operator=( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22208,59 +21785,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindImageMemoryDeviceGroupInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr, - uint32_t splitInstanceBindRegionCount_ = 0, - const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ ) - , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ ) - {} - - BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; - const void* pNext = nullptr; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - const vk::Rect2D* pSplitInstanceBindRegions; - }; - static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindImageMemoryDeviceGroupInfo : public layout::BindImageMemoryDeviceGroupInfo + struct BindImageMemoryDeviceGroupInfo { VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr, uint32_t splitInstanceBindRegionCount_ = 0, const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_, splitInstanceBindRegionCount_, pSplitInstanceBindRegions_ ) + : deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) + , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ ) + , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ ) {} + vk::BindImageMemoryDeviceGroupInfo & operator=( vk::BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemoryDeviceGroupInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemoryDeviceGroupInfo( rhs ) - {} + { + *this = rhs; + } BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindImageMemoryDeviceGroupInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22319,61 +21869,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindImageMemoryDeviceGroupInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; + const void* pNext = nullptr; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const vk::Rect2D* pSplitInstanceBindRegions; }; static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindImageMemoryInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( vk::Image image_ = vk::Image(), - vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - {} - - BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindImageMemoryInfo; - const void* pNext = nullptr; - vk::Image image; - vk::DeviceMemory memory; - vk::DeviceSize memoryOffset; - }; - static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindImageMemoryInfo : public layout::BindImageMemoryInfo + struct BindImageMemoryInfo { VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( vk::Image image_ = vk::Image(), vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemoryInfo( image_, memory_, memoryOffset_ ) + : image( image_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) {} + vk::BindImageMemoryInfo & operator=( vk::BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemoryInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemoryInfo( rhs ) - {} + { + *this = rhs; + } BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindImageMemoryInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22425,57 +21955,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindImageMemoryInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindImageMemoryInfo; + const void* pNext = nullptr; + vk::Image image; + vk::DeviceMemory memory; + vk::DeviceSize memoryOffset; }; static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindImageMemorySwapchainInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(), - uint32_t imageIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : swapchain( swapchain_ ) - , imageIndex( imageIndex_ ) - {} - - BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; - const void* pNext = nullptr; - vk::SwapchainKHR swapchain; - uint32_t imageIndex; - }; - static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct BindImageMemorySwapchainInfoKHR : public layout::BindImageMemorySwapchainInfoKHR + struct BindImageMemorySwapchainInfoKHR { VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(), uint32_t imageIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemorySwapchainInfoKHR( swapchain_, imageIndex_ ) + : swapchain( swapchain_ ) + , imageIndex( imageIndex_ ) {} + vk::BindImageMemorySwapchainInfoKHR & operator=( vk::BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemorySwapchainInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemorySwapchainInfoKHR( rhs ) - {} + { + *this = rhs; + } BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindImageMemorySwapchainInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22520,53 +22031,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindImageMemorySwapchainInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; + const void* pNext = nullptr; + vk::SwapchainKHR swapchain; + uint32_t imageIndex; }; static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindImagePlaneMemoryInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT - : planeAspect( planeAspect_ ) - {} - - BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindImagePlaneMemoryInfo; - const void* pNext = nullptr; - vk::ImageAspectFlagBits planeAspect; - }; - static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindImagePlaneMemoryInfo : public layout::BindImagePlaneMemoryInfo + struct BindImagePlaneMemoryInfo { VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT - : layout::BindImagePlaneMemoryInfo( planeAspect_ ) + : planeAspect( planeAspect_ ) {} + vk::BindImagePlaneMemoryInfo & operator=( vk::BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImagePlaneMemoryInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindImagePlaneMemoryInfo( rhs ) - {} + { + *this = rhs; + } BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindImagePlaneMemoryInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22604,8 +22097,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindImagePlaneMemoryInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindImagePlaneMemoryInfo; + const void* pNext = nullptr; + vk::ImageAspectFlagBits planeAspect; }; static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -22626,12 +22121,12 @@ namespace VULKAN_HPP_NAMESPACE SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22711,12 +22206,12 @@ namespace VULKAN_HPP_NAMESPACE SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22780,12 +22275,12 @@ namespace VULKAN_HPP_NAMESPACE SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22849,12 +22344,12 @@ namespace VULKAN_HPP_NAMESPACE ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageSubresource& operator=( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22925,12 +22420,12 @@ namespace VULKAN_HPP_NAMESPACE Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Offset3D& operator=( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23001,12 +22496,12 @@ namespace VULKAN_HPP_NAMESPACE Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Extent3D& operator=( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23076,12 +22571,12 @@ namespace VULKAN_HPP_NAMESPACE SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23169,12 +22664,12 @@ namespace VULKAN_HPP_NAMESPACE SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23226,62 +22721,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindSparseInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, - const vk::Semaphore* pWaitSemaphores_ = nullptr, - uint32_t bufferBindCount_ = 0, - const vk::SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, - uint32_t imageOpaqueBindCount_ = 0, - const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, - uint32_t imageBindCount_ = 0, - const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , bufferBindCount( bufferBindCount_ ) - , pBufferBinds( pBufferBinds_ ) - , imageOpaqueBindCount( imageOpaqueBindCount_ ) - , pImageOpaqueBinds( pImageOpaqueBinds_ ) - , imageBindCount( imageBindCount_ ) - , pImageBinds( pImageBinds_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) - {} - - BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindSparseInfo; - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const vk::Semaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const vk::SparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const vk::SparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const vk::Semaphore* pSignalSemaphores; - }; - static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindSparseInfo : public layout::BindSparseInfo + struct BindSparseInfo { VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const vk::Semaphore* pWaitSemaphores_ = nullptr, @@ -23293,16 +22733,32 @@ namespace VULKAN_HPP_NAMESPACE const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BindSparseInfo( waitSemaphoreCount_, pWaitSemaphores_, bufferBindCount_, pBufferBinds_, imageOpaqueBindCount_, pImageOpaqueBinds_, imageBindCount_, pImageBinds_, signalSemaphoreCount_, pSignalSemaphores_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , bufferBindCount( bufferBindCount_ ) + , pBufferBinds( pBufferBinds_ ) + , imageOpaqueBindCount( imageOpaqueBindCount_ ) + , pImageOpaqueBinds( pImageOpaqueBinds_ ) + , imageBindCount( imageBindCount_ ) + , pImageBinds( pImageBinds_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphores( pSignalSemaphores_ ) {} + vk::BindSparseInfo & operator=( vk::BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindSparseInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindSparseInfo( rhs ) - {} + { + *this = rhs; + } BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindSparseInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -23403,8 +22859,19 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindSparseInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindSparseInfo; + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const vk::Semaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const vk::SparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const vk::SparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const vk::Semaphore* pSignalSemaphores; }; static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -23421,12 +22888,12 @@ namespace VULKAN_HPP_NAMESPACE BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } BufferCopy& operator=( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23478,50 +22945,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(), - vk::DeviceSize size_ = 0, - vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(), - vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , size( size_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - {} - - BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferCreateInfo; - const void* pNext = nullptr; - vk::BufferCreateFlags flags; - vk::DeviceSize size; - vk::BufferUsageFlags usage; - vk::SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - }; - static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct BufferCreateInfo : public layout::BufferCreateInfo + struct BufferCreateInfo { VULKAN_HPP_CONSTEXPR BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(), vk::DeviceSize size_ = 0, @@ -23529,16 +22953,28 @@ namespace VULKAN_HPP_NAMESPACE vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BufferCreateInfo( flags_, size_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ ) + : flags( flags_ ) + , size( size_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) {} + vk::BufferCreateInfo & operator=( vk::BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferCreateInfo( rhs ) - {} + { + *this = rhs; + } BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -23611,53 +23047,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eBufferCreateInfo; + const void* pNext = nullptr; + vk::BufferCreateFlags flags; + vk::DeviceSize size; + vk::BufferUsageFlags usage; + vk::SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; }; static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferDeviceAddressCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 ) VULKAN_HPP_NOEXCEPT - : deviceAddress( deviceAddress_ ) - {} - - BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT; - const void* pNext = nullptr; - vk::DeviceAddress deviceAddress; - }; - static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct BufferDeviceAddressCreateInfoEXT : public layout::BufferDeviceAddressCreateInfoEXT + struct BufferDeviceAddressCreateInfoEXT { VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BufferDeviceAddressCreateInfoEXT( deviceAddress_ ) + : deviceAddress( deviceAddress_ ) {} + vk::BufferDeviceAddressCreateInfoEXT & operator=( vk::BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferDeviceAddressCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferDeviceAddressCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferDeviceAddressCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -23695,53 +23117,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferDeviceAddressCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT; + const void* pNext = nullptr; + vk::DeviceAddress deviceAddress; }; static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferDeviceAddressInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - {} - - BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferDeviceAddressInfoEXT; - const void* pNext = nullptr; - vk::Buffer buffer; - }; - static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct BufferDeviceAddressInfoEXT : public layout::BufferDeviceAddressInfoEXT + struct BufferDeviceAddressInfoEXT { VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : layout::BufferDeviceAddressInfoEXT( buffer_ ) + : buffer( buffer_ ) {} + vk::BufferDeviceAddressInfoEXT & operator=( vk::BufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferDeviceAddressInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferDeviceAddressInfoEXT( rhs ) - {} + { + *this = rhs; + } BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferDeviceAddressInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -23779,8 +23182,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferDeviceAddressInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eBufferDeviceAddressInfoEXT; + const void* pNext = nullptr; + vk::Buffer buffer; }; static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -23799,12 +23204,12 @@ namespace VULKAN_HPP_NAMESPACE ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23882,12 +23287,12 @@ namespace VULKAN_HPP_NAMESPACE BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23963,53 +23368,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferMemoryBarrier - { - protected: - VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), - vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), - uint32_t srcQueueFamilyIndex_ = 0, - uint32_t dstQueueFamilyIndex_ = 0, - vk::Buffer buffer_ = vk::Buffer(), - vk::DeviceSize offset_ = 0, - vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , buffer( buffer_ ) - , offset( offset_ ) - , size( size_ ) - {} - - BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferMemoryBarrier; - const void* pNext = nullptr; - vk::AccessFlags srcAccessMask; - vk::AccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - vk::Buffer buffer; - vk::DeviceSize offset; - vk::DeviceSize size; - }; - static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "layout struct and wrapper have different size!" ); - } - - struct BufferMemoryBarrier : public layout::BufferMemoryBarrier + struct BufferMemoryBarrier { VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), @@ -24018,16 +23377,29 @@ namespace VULKAN_HPP_NAMESPACE vk::Buffer buffer_ = vk::Buffer(), vk::DeviceSize offset_ = 0, vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BufferMemoryBarrier( srcAccessMask_, dstAccessMask_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, buffer_, offset_, size_ ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) + , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) + , buffer( buffer_ ) + , offset( offset_ ) + , size( size_ ) {} + vk::BufferMemoryBarrier & operator=( vk::BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferMemoryBarrier ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferMemoryBarrier( rhs ) - {} + { + *this = rhs; + } BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferMemoryBarrier::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24107,53 +23479,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferMemoryBarrier::sType; + public: + const vk::StructureType sType = StructureType::eBufferMemoryBarrier; + const void* pNext = nullptr; + vk::AccessFlags srcAccessMask; + vk::AccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + vk::Buffer buffer; + vk::DeviceSize offset; + vk::DeviceSize size; }; static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferMemoryRequirementsInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - {} - - BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; - const void* pNext = nullptr; - vk::Buffer buffer; - }; - static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct BufferMemoryRequirementsInfo2 : public layout::BufferMemoryRequirementsInfo2 + struct BufferMemoryRequirementsInfo2 { VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : layout::BufferMemoryRequirementsInfo2( buffer_ ) + : buffer( buffer_ ) {} + vk::BufferMemoryRequirementsInfo2 & operator=( vk::BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferMemoryRequirementsInfo2( rhs ) - {} + { + *this = rhs; + } BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferMemoryRequirementsInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24191,69 +23550,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferMemoryRequirementsInfo2::sType; + public: + const vk::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; + const void* pNext = nullptr; + vk::Buffer buffer; }; static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferViewCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( vk::BufferViewCreateFlags flags_ = vk::BufferViewCreateFlags(), - vk::Buffer buffer_ = vk::Buffer(), - vk::Format format_ = vk::Format::eUndefined, - vk::DeviceSize offset_ = 0, - vk::DeviceSize range_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , buffer( buffer_ ) - , format( format_ ) - , offset( offset_ ) - , range( range_ ) - {} - - BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferViewCreateInfo; - const void* pNext = nullptr; - vk::BufferViewCreateFlags flags; - vk::Buffer buffer; - vk::Format format; - vk::DeviceSize offset; - vk::DeviceSize range; - }; - static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct BufferViewCreateInfo : public layout::BufferViewCreateInfo + struct BufferViewCreateInfo { VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( vk::BufferViewCreateFlags flags_ = vk::BufferViewCreateFlags(), vk::Buffer buffer_ = vk::Buffer(), vk::Format format_ = vk::Format::eUndefined, vk::DeviceSize offset_ = 0, vk::DeviceSize range_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BufferViewCreateInfo( flags_, buffer_, format_, offset_, range_ ) + : flags( flags_ ) + , buffer( buffer_ ) + , format( format_ ) + , offset( offset_ ) + , range( range_ ) {} + vk::BufferViewCreateInfo & operator=( vk::BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferViewCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferViewCreateInfo( rhs ) - {} + { + *this = rhs; + } BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferViewCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24319,53 +23651,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferViewCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eBufferViewCreateInfo; + const void* pNext = nullptr; + vk::BufferViewCreateFlags flags; + vk::Buffer buffer; + vk::Format format; + vk::DeviceSize offset; + vk::DeviceSize range; }; static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CalibratedTimestampInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT - : timeDomain( timeDomain_ ) - {} - - CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCalibratedTimestampInfoEXT; - const void* pNext = nullptr; - vk::TimeDomainEXT timeDomain; - }; - static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct CalibratedTimestampInfoEXT : public layout::CalibratedTimestampInfoEXT + struct CalibratedTimestampInfoEXT { VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT - : layout::CalibratedTimestampInfoEXT( timeDomain_ ) + : timeDomain( timeDomain_ ) {} + vk::CalibratedTimestampInfoEXT & operator=( vk::CalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CalibratedTimestampInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CalibratedTimestampInfoEXT( rhs ) - {} + { + *this = rhs; + } CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CalibratedTimestampInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24403,53 +23720,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CalibratedTimestampInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eCalibratedTimestampInfoEXT; + const void* pNext = nullptr; + vk::TimeDomainEXT timeDomain; }; static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct CheckpointDataNV { - struct CheckpointDataNV - { - protected: - CheckpointDataNV() VULKAN_HPP_NOEXCEPT - {} - - CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCheckpointDataNV; - void* pNext = nullptr; - vk::PipelineStageFlagBits stage; - void* pCheckpointMarker; - }; - static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "layout struct and wrapper have different size!" ); - } - - struct CheckpointDataNV : public layout::CheckpointDataNV - { - CheckpointDataNV() VULKAN_HPP_NOEXCEPT - : layout::CheckpointDataNV() + CheckpointDataNV( vk::PipelineStageFlagBits stage_ = vk::PipelineStageFlagBits::eTopOfPipe, + void* pCheckpointMarker_ = nullptr ) VULKAN_HPP_NOEXCEPT + : stage( stage_ ) + , pCheckpointMarker( pCheckpointMarker_ ) {} + vk::CheckpointDataNV & operator=( vk::CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CheckpointDataNV ) - sizeof( vk::StructureType ) ); + return *this; + } + CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CheckpointDataNV( rhs ) - {} + { + *this = rhs; + } CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CheckpointDataNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24476,8 +23776,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CheckpointDataNV::sType; + public: + const vk::StructureType sType = StructureType::eCheckpointDataNV; + void* pNext = nullptr; + vk::PipelineStageFlagBits stage; + void* pCheckpointMarker; }; static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -24541,12 +23844,12 @@ namespace VULKAN_HPP_NAMESPACE ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24644,12 +23947,12 @@ namespace VULKAN_HPP_NAMESPACE ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ClearAttachment& operator=( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24701,12 +24004,12 @@ namespace VULKAN_HPP_NAMESPACE ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ClearRect& operator=( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24770,12 +24073,12 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24827,62 +24130,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CmdProcessCommandsInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(), - vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(), - uint32_t indirectCommandsTokenCount_ = 0, - const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, - uint32_t maxSequencesCount_ = 0, - vk::CommandBuffer targetCommandBuffer_ = vk::CommandBuffer(), - vk::Buffer sequencesCountBuffer_ = vk::Buffer(), - vk::DeviceSize sequencesCountOffset_ = 0, - vk::Buffer sequencesIndexBuffer_ = vk::Buffer(), - vk::DeviceSize sequencesIndexOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : objectTable( objectTable_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , indirectCommandsTokenCount( indirectCommandsTokenCount_ ) - , pIndirectCommandsTokens( pIndirectCommandsTokens_ ) - , maxSequencesCount( maxSequencesCount_ ) - , targetCommandBuffer( targetCommandBuffer_ ) - , sequencesCountBuffer( sequencesCountBuffer_ ) - , sequencesCountOffset( sequencesCountOffset_ ) - , sequencesIndexBuffer( sequencesIndexBuffer_ ) - , sequencesIndexOffset( sequencesIndexOffset_ ) - {} - - CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCmdProcessCommandsInfoNVX; - const void* pNext = nullptr; - vk::ObjectTableNVX objectTable; - vk::IndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t indirectCommandsTokenCount; - const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens; - uint32_t maxSequencesCount; - vk::CommandBuffer targetCommandBuffer; - vk::Buffer sequencesCountBuffer; - vk::DeviceSize sequencesCountOffset; - vk::Buffer sequencesIndexBuffer; - vk::DeviceSize sequencesIndexOffset; - }; - static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct CmdProcessCommandsInfoNVX : public layout::CmdProcessCommandsInfoNVX + struct CmdProcessCommandsInfoNVX { VULKAN_HPP_CONSTEXPR CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(), vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(), @@ -24894,16 +24142,32 @@ namespace VULKAN_HPP_NAMESPACE vk::DeviceSize sequencesCountOffset_ = 0, vk::Buffer sequencesIndexBuffer_ = vk::Buffer(), vk::DeviceSize sequencesIndexOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CmdProcessCommandsInfoNVX( objectTable_, indirectCommandsLayout_, indirectCommandsTokenCount_, pIndirectCommandsTokens_, maxSequencesCount_, targetCommandBuffer_, sequencesCountBuffer_, sequencesCountOffset_, sequencesIndexBuffer_, sequencesIndexOffset_ ) + : objectTable( objectTable_ ) + , indirectCommandsLayout( indirectCommandsLayout_ ) + , indirectCommandsTokenCount( indirectCommandsTokenCount_ ) + , pIndirectCommandsTokens( pIndirectCommandsTokens_ ) + , maxSequencesCount( maxSequencesCount_ ) + , targetCommandBuffer( targetCommandBuffer_ ) + , sequencesCountBuffer( sequencesCountBuffer_ ) + , sequencesCountOffset( sequencesCountOffset_ ) + , sequencesIndexBuffer( sequencesIndexBuffer_ ) + , sequencesIndexOffset( sequencesIndexOffset_ ) {} + vk::CmdProcessCommandsInfoNVX & operator=( vk::CmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CmdProcessCommandsInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CmdProcessCommandsInfoNVX( rhs ) - {} + { + *this = rhs; + } CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CmdProcessCommandsInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25004,61 +24268,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CmdProcessCommandsInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eCmdProcessCommandsInfoNVX; + const void* pNext = nullptr; + vk::ObjectTableNVX objectTable; + vk::IndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t indirectCommandsTokenCount; + const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens; + uint32_t maxSequencesCount; + vk::CommandBuffer targetCommandBuffer; + vk::Buffer sequencesCountBuffer; + vk::DeviceSize sequencesCountOffset; + vk::Buffer sequencesIndexBuffer; + vk::DeviceSize sequencesIndexOffset; }; static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CmdReserveSpaceForCommandsInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(), - vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(), - uint32_t maxSequencesCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : objectTable( objectTable_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , maxSequencesCount( maxSequencesCount_ ) - {} - - CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX; - const void* pNext = nullptr; - vk::ObjectTableNVX objectTable; - vk::IndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t maxSequencesCount; - }; - static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct CmdReserveSpaceForCommandsInfoNVX : public layout::CmdReserveSpaceForCommandsInfoNVX + struct CmdReserveSpaceForCommandsInfoNVX { VULKAN_HPP_CONSTEXPR CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(), vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(), uint32_t maxSequencesCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CmdReserveSpaceForCommandsInfoNVX( objectTable_, indirectCommandsLayout_, maxSequencesCount_ ) + : objectTable( objectTable_ ) + , indirectCommandsLayout( indirectCommandsLayout_ ) + , maxSequencesCount( maxSequencesCount_ ) {} + vk::CmdReserveSpaceForCommandsInfoNVX & operator=( vk::CmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CmdReserveSpaceForCommandsInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CmdReserveSpaceForCommandsInfoNVX( rhs ) - {} + { + *this = rhs; + } CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CmdReserveSpaceForCommandsInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25110,8 +24360,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CmdReserveSpaceForCommandsInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX; + const void* pNext = nullptr; + vk::ObjectTableNVX objectTable; + vk::IndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t maxSequencesCount; }; static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -25128,12 +24382,12 @@ namespace VULKAN_HPP_NAMESPACE CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -25199,12 +24453,12 @@ namespace VULKAN_HPP_NAMESPACE CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -25264,55 +24518,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandBufferAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(), - vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary, - uint32_t commandBufferCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : commandPool( commandPool_ ) - , level( level_ ) - , commandBufferCount( commandBufferCount_ ) - {} - - CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandBufferAllocateInfo; - const void* pNext = nullptr; - vk::CommandPool commandPool; - vk::CommandBufferLevel level; - uint32_t commandBufferCount; - }; - static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct CommandBufferAllocateInfo : public layout::CommandBufferAllocateInfo + struct CommandBufferAllocateInfo { VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(), vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferAllocateInfo( commandPool_, level_, commandBufferCount_ ) + : commandPool( commandPool_ ) + , level( level_ ) + , commandBufferCount( commandBufferCount_ ) {} + vk::CommandBufferAllocateInfo & operator=( vk::CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferAllocateInfo( rhs ) - {} + { + *this = rhs; + } CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandBufferAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25364,56 +24593,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandBufferAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eCommandBufferAllocateInfo; + const void* pNext = nullptr; + vk::CommandPool commandPool; + vk::CommandBufferLevel level; + uint32_t commandBufferCount; }; static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandBufferInheritanceInfo - { - protected: - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(), - uint32_t subpass_ = 0, - vk::Framebuffer framebuffer_ = vk::Framebuffer(), - vk::Bool32 occlusionQueryEnable_ = 0, - vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(), - vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT - : renderPass( renderPass_ ) - , subpass( subpass_ ) - , framebuffer( framebuffer_ ) - , occlusionQueryEnable( occlusionQueryEnable_ ) - , queryFlags( queryFlags_ ) - , pipelineStatistics( pipelineStatistics_ ) - {} - - CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandBufferInheritanceInfo; - const void* pNext = nullptr; - vk::RenderPass renderPass; - uint32_t subpass; - vk::Framebuffer framebuffer; - vk::Bool32 occlusionQueryEnable; - vk::QueryControlFlags queryFlags; - vk::QueryPipelineStatisticFlags pipelineStatistics; - }; - static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "layout struct and wrapper have different size!" ); - } - - struct CommandBufferInheritanceInfo : public layout::CommandBufferInheritanceInfo + struct CommandBufferInheritanceInfo { VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(), uint32_t subpass_ = 0, @@ -25421,16 +24611,28 @@ namespace VULKAN_HPP_NAMESPACE vk::Bool32 occlusionQueryEnable_ = 0, vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(), vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferInheritanceInfo( renderPass_, subpass_, framebuffer_, occlusionQueryEnable_, queryFlags_, pipelineStatistics_ ) + : renderPass( renderPass_ ) + , subpass( subpass_ ) + , framebuffer( framebuffer_ ) + , occlusionQueryEnable( occlusionQueryEnable_ ) + , queryFlags( queryFlags_ ) + , pipelineStatistics( pipelineStatistics_ ) {} + vk::CommandBufferInheritanceInfo & operator=( vk::CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferInheritanceInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferInheritanceInfo( rhs ) - {} + { + *this = rhs; + } CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandBufferInheritanceInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25503,57 +24705,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandBufferInheritanceInfo::sType; + public: + const vk::StructureType sType = StructureType::eCommandBufferInheritanceInfo; + const void* pNext = nullptr; + vk::RenderPass renderPass; + uint32_t subpass; + vk::Framebuffer framebuffer; + vk::Bool32 occlusionQueryEnable; + vk::QueryControlFlags queryFlags; + vk::QueryPipelineStatisticFlags pipelineStatistics; }; static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandBufferBeginInfo - { - protected: - VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(), - const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pInheritanceInfo( pInheritanceInfo_ ) - {} - - CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandBufferBeginInfo; - const void* pNext = nullptr; - vk::CommandBufferUsageFlags flags; - const vk::CommandBufferInheritanceInfo* pInheritanceInfo; - }; - static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "layout struct and wrapper have different size!" ); - } - - struct CommandBufferBeginInfo : public layout::CommandBufferBeginInfo + struct CommandBufferBeginInfo { VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(), const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferBeginInfo( flags_, pInheritanceInfo_ ) + : flags( flags_ ) + , pInheritanceInfo( pInheritanceInfo_ ) {} + vk::CommandBufferBeginInfo & operator=( vk::CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferBeginInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferBeginInfo( rhs ) - {} + { + *this = rhs; + } CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandBufferBeginInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25598,53 +24784,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandBufferBeginInfo::sType; + public: + const vk::StructureType sType = StructureType::eCommandBufferBeginInfo; + const void* pNext = nullptr; + vk::CommandBufferUsageFlags flags; + const vk::CommandBufferInheritanceInfo* pInheritanceInfo; }; static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandBufferInheritanceConditionalRenderingInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : conditionalRenderingEnable( conditionalRenderingEnable_ ) - {} - - CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; - const void* pNext = nullptr; - vk::Bool32 conditionalRenderingEnable; - }; - static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct CommandBufferInheritanceConditionalRenderingInfoEXT : public layout::CommandBufferInheritanceConditionalRenderingInfoEXT + struct CommandBufferInheritanceConditionalRenderingInfoEXT { VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( conditionalRenderingEnable_ ) + : conditionalRenderingEnable( conditionalRenderingEnable_ ) {} + vk::CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( vk::CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferInheritanceConditionalRenderingInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( rhs ) - {} + { + *this = rhs; + } CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandBufferInheritanceConditionalRenderingInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25682,57 +24850,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandBufferInheritanceConditionalRenderingInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; + const void* pNext = nullptr; + vk::Bool32 conditionalRenderingEnable; }; static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandPoolCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(), - uint32_t queueFamilyIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - {} - - CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandPoolCreateInfo; - const void* pNext = nullptr; - vk::CommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; - }; - static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct CommandPoolCreateInfo : public layout::CommandPoolCreateInfo + struct CommandPoolCreateInfo { VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CommandPoolCreateInfo( flags_, queueFamilyIndex_ ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) {} + vk::CommandPoolCreateInfo & operator=( vk::CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandPoolCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandPoolCreateInfo( rhs ) - {} + { + *this = rhs; + } CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandPoolCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25777,8 +24924,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandPoolCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eCommandPoolCreateInfo; + const void* pNext = nullptr; + vk::CommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; }; static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -25795,12 +24945,12 @@ namespace VULKAN_HPP_NAMESPACE SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -25866,12 +25016,12 @@ namespace VULKAN_HPP_NAMESPACE SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -25931,63 +25081,34 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineShaderStageCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( vk::PipelineShaderStageCreateFlags flags_ = vk::PipelineShaderStageCreateFlags(), - vk::ShaderStageFlagBits stage_ = vk::ShaderStageFlagBits::eVertex, - vk::ShaderModule module_ = vk::ShaderModule(), - const char* pName_ = nullptr, - const vk::SpecializationInfo* pSpecializationInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , stage( stage_ ) - , module( module_ ) - , pName( pName_ ) - , pSpecializationInfo( pSpecializationInfo_ ) - {} - - PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineShaderStageCreateInfo; - const void* pNext = nullptr; - vk::PipelineShaderStageCreateFlags flags; - vk::ShaderStageFlagBits stage; - vk::ShaderModule module; - const char* pName; - const vk::SpecializationInfo* pSpecializationInfo; - }; - static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineShaderStageCreateInfo : public layout::PipelineShaderStageCreateInfo + struct PipelineShaderStageCreateInfo { VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( vk::PipelineShaderStageCreateFlags flags_ = vk::PipelineShaderStageCreateFlags(), vk::ShaderStageFlagBits stage_ = vk::ShaderStageFlagBits::eVertex, vk::ShaderModule module_ = vk::ShaderModule(), const char* pName_ = nullptr, const vk::SpecializationInfo* pSpecializationInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineShaderStageCreateInfo( flags_, stage_, module_, pName_, pSpecializationInfo_ ) + : flags( flags_ ) + , stage( stage_ ) + , module( module_ ) + , pName( pName_ ) + , pSpecializationInfo( pSpecializationInfo_ ) {} + vk::PipelineShaderStageCreateInfo & operator=( vk::PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineShaderStageCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineShaderStageCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineShaderStageCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26053,69 +25174,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineShaderStageCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineShaderStageCreateInfo; + const void* pNext = nullptr; + vk::PipelineShaderStageCreateFlags flags; + vk::ShaderStageFlagBits stage; + vk::ShaderModule module; + const char* pName; + const vk::SpecializationInfo* pSpecializationInfo; }; static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ComputePipelineCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), - vk::PipelineShaderStageCreateInfo stage_ = vk::PipelineShaderStageCreateInfo(), - vk::PipelineLayout layout_ = vk::PipelineLayout(), - vk::Pipeline basePipelineHandle_ = vk::Pipeline(), - int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , stage( stage_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - {} - - ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eComputePipelineCreateInfo; - const void* pNext = nullptr; - vk::PipelineCreateFlags flags; - vk::PipelineShaderStageCreateInfo stage; - vk::PipelineLayout layout; - vk::Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ComputePipelineCreateInfo : public layout::ComputePipelineCreateInfo + struct ComputePipelineCreateInfo { VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), vk::PipelineShaderStageCreateInfo stage_ = vk::PipelineShaderStageCreateInfo(), vk::PipelineLayout layout_ = vk::PipelineLayout(), vk::Pipeline basePipelineHandle_ = vk::Pipeline(), int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ComputePipelineCreateInfo( flags_, stage_, layout_, basePipelineHandle_, basePipelineIndex_ ) + : flags( flags_ ) + , stage( stage_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) {} + vk::ComputePipelineCreateInfo & operator=( vk::ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ComputePipelineCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ComputePipelineCreateInfo( rhs ) - {} + { + *this = rhs; + } ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ComputePipelineCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26181,61 +25279,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ComputePipelineCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eComputePipelineCreateInfo; + const void* pNext = nullptr; + vk::PipelineCreateFlags flags; + vk::PipelineShaderStageCreateInfo stage; + vk::PipelineLayout layout; + vk::Pipeline basePipelineHandle; + int32_t basePipelineIndex; }; static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ConditionalRenderingBeginInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(), - vk::DeviceSize offset_ = 0, - vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - , offset( offset_ ) - , flags( flags_ ) - {} - - ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT; - const void* pNext = nullptr; - vk::Buffer buffer; - vk::DeviceSize offset; - vk::ConditionalRenderingFlagsEXT flags; - }; - static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ConditionalRenderingBeginInfoEXT : public layout::ConditionalRenderingBeginInfoEXT + struct ConditionalRenderingBeginInfoEXT { VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(), vk::DeviceSize offset_ = 0, vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : layout::ConditionalRenderingBeginInfoEXT( buffer_, offset_, flags_ ) + : buffer( buffer_ ) + , offset( offset_ ) + , flags( flags_ ) {} + vk::ConditionalRenderingBeginInfoEXT & operator=( vk::ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ConditionalRenderingBeginInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ConditionalRenderingBeginInfoEXT( rhs ) - {} + { + *this = rhs; + } ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ConditionalRenderingBeginInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26287,8 +25366,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ConditionalRenderingBeginInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT; + const void* pNext = nullptr; + vk::Buffer buffer; + vk::DeviceSize offset; + vk::ConditionalRenderingFlagsEXT flags; }; static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -26307,12 +25390,12 @@ namespace VULKAN_HPP_NAMESPACE ConformanceVersionKHR( VkConformanceVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -26372,56 +25455,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CooperativeMatrixPropertiesNV - { - protected: - VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0, - uint32_t NSize_ = 0, - uint32_t KSize_ = 0, - vk::ComponentTypeNV AType_ = vk::ComponentTypeNV::eFloat16, - vk::ComponentTypeNV BType_ = vk::ComponentTypeNV::eFloat16, - vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16, - vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16, - vk::ScopeNV scope_ = vk::ScopeNV::eDevice ) VULKAN_HPP_NOEXCEPT - : MSize( MSize_ ) - , NSize( NSize_ ) - , KSize( KSize_ ) - , AType( AType_ ) - , BType( BType_ ) - , CType( CType_ ) - , DType( DType_ ) - , scope( scope_ ) - {} - - CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCooperativeMatrixPropertiesNV; - void* pNext = nullptr; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - vk::ComponentTypeNV AType; - vk::ComponentTypeNV BType; - vk::ComponentTypeNV CType; - vk::ComponentTypeNV DType; - vk::ScopeNV scope; - }; - static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct CooperativeMatrixPropertiesNV : public layout::CooperativeMatrixPropertiesNV + struct CooperativeMatrixPropertiesNV { VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0, uint32_t NSize_ = 0, @@ -26431,16 +25465,30 @@ namespace VULKAN_HPP_NAMESPACE vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16, vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16, vk::ScopeNV scope_ = vk::ScopeNV::eDevice ) VULKAN_HPP_NOEXCEPT - : layout::CooperativeMatrixPropertiesNV( MSize_, NSize_, KSize_, AType_, BType_, CType_, DType_, scope_ ) + : MSize( MSize_ ) + , NSize( NSize_ ) + , KSize( KSize_ ) + , AType( AType_ ) + , BType( BType_ ) + , CType( CType_ ) + , DType( DType_ ) + , scope( scope_ ) {} + vk::CooperativeMatrixPropertiesNV & operator=( vk::CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CooperativeMatrixPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CooperativeMatrixPropertiesNV( rhs ) - {} + { + *this = rhs; + } CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CooperativeMatrixPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26527,59 +25575,22 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CooperativeMatrixPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::eCooperativeMatrixPropertiesNV; + void* pNext = nullptr; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + vk::ComponentTypeNV AType; + vk::ComponentTypeNV BType; + vk::ComponentTypeNV CType; + vk::ComponentTypeNV DType; + vk::ScopeNV scope; }; static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CopyDescriptorSet - { - protected: - VULKAN_HPP_CONSTEXPR CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(), - uint32_t srcBinding_ = 0, - uint32_t srcArrayElement_ = 0, - vk::DescriptorSet dstSet_ = vk::DescriptorSet(), - uint32_t dstBinding_ = 0, - uint32_t dstArrayElement_ = 0, - uint32_t descriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : srcSet( srcSet_ ) - , srcBinding( srcBinding_ ) - , srcArrayElement( srcArrayElement_ ) - , dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - {} - - CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCopyDescriptorSet; - const void* pNext = nullptr; - vk::DescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - vk::DescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - }; - static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "layout struct and wrapper have different size!" ); - } - - struct CopyDescriptorSet : public layout::CopyDescriptorSet + struct CopyDescriptorSet { VULKAN_HPP_CONSTEXPR CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(), uint32_t srcBinding_ = 0, @@ -26588,16 +25599,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CopyDescriptorSet( srcSet_, srcBinding_, srcArrayElement_, dstSet_, dstBinding_, dstArrayElement_, descriptorCount_ ) + : srcSet( srcSet_ ) + , srcBinding( srcBinding_ ) + , srcArrayElement( srcArrayElement_ ) + , dstSet( dstSet_ ) + , dstBinding( dstBinding_ ) + , dstArrayElement( dstArrayElement_ ) + , descriptorCount( descriptorCount_ ) {} + vk::CopyDescriptorSet & operator=( vk::CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CopyDescriptorSet ) - sizeof( vk::StructureType ) ); + return *this; + } + CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CopyDescriptorSet( rhs ) - {} + { + *this = rhs; + } CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CopyDescriptorSet::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26677,67 +25701,48 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CopyDescriptorSet::sType; + public: + const vk::StructureType sType = StructureType::eCopyDescriptorSet; + const void* pNext = nullptr; + vk::DescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + vk::DescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; }; static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct D3D12FenceSubmitInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, - const uint64_t* pWaitSemaphoreValues_ = nullptr, - uint32_t signalSemaphoreValuesCount_ = 0, - const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) - , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) - , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ) - , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) - {} - - D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; - const void* pNext = nullptr; - uint32_t waitSemaphoreValuesCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValuesCount; - const uint64_t* pSignalSemaphoreValues; - }; - static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct D3D12FenceSubmitInfoKHR : public layout::D3D12FenceSubmitInfoKHR + struct D3D12FenceSubmitInfoKHR { VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::D3D12FenceSubmitInfoKHR( waitSemaphoreValuesCount_, pWaitSemaphoreValues_, signalSemaphoreValuesCount_, pSignalSemaphoreValues_ ) + : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) + , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) + , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ) + , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) {} + vk::D3D12FenceSubmitInfoKHR & operator=( vk::D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::D3D12FenceSubmitInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::D3D12FenceSubmitInfoKHR( rhs ) - {} + { + *this = rhs; + } D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::D3D12FenceSubmitInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26796,60 +25801,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::D3D12FenceSubmitInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; + const void* pNext = nullptr; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; }; static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct DebugMarkerMarkerInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, - std::array const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : pMarkerName( pMarkerName_ ) - , color{} - { - vk::ConstExpressionArrayCopy::copy( color, color_ ); - } - - DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; - const void* pNext = nullptr; - const char* pMarkerName; - float color[4]; - }; - static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugMarkerMarkerInfoEXT : public layout::DebugMarkerMarkerInfoEXT + struct DebugMarkerMarkerInfoEXT { VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, std::array const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerMarkerInfoEXT( pMarkerName_, color_ ) - {} + : pMarkerName( pMarkerName_ ) + , color{} + { + vk::ConstExpressionArrayCopy::copy( color, color_ ); + } + + vk::DebugMarkerMarkerInfoEXT & operator=( vk::DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerMarkerInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerMarkerInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugMarkerMarkerInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26894,61 +25881,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugMarkerMarkerInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; + const void* pNext = nullptr; + const char* pMarkerName; + float color[4]; }; static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugMarkerObjectNameInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown, - uint64_t object_ = 0, - const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT - : objectType( objectType_ ) - , object( object_ ) - , pObjectName( pObjectName_ ) - {} - - DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; - const void* pNext = nullptr; - vk::DebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; - }; - static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugMarkerObjectNameInfoEXT : public layout::DebugMarkerObjectNameInfoEXT + struct DebugMarkerObjectNameInfoEXT { VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerObjectNameInfoEXT( objectType_, object_, pObjectName_ ) + : objectType( objectType_ ) + , object( object_ ) + , pObjectName( pObjectName_ ) {} + vk::DebugMarkerObjectNameInfoEXT & operator=( vk::DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerObjectNameInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerObjectNameInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugMarkerObjectNameInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27000,69 +25965,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugMarkerObjectNameInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; + const void* pNext = nullptr; + vk::DebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; }; static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugMarkerObjectTagInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown, - uint64_t object_ = 0, - uint64_t tagName_ = 0, - size_t tagSize_ = 0, - const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT - : objectType( objectType_ ) - , object( object_ ) - , tagName( tagName_ ) - , tagSize( tagSize_ ) - , pTag( pTag_ ) - {} - - DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; - const void* pNext = nullptr; - vk::DebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; - }; - static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugMarkerObjectTagInfoEXT : public layout::DebugMarkerObjectTagInfoEXT + struct DebugMarkerObjectTagInfoEXT { VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerObjectTagInfoEXT( objectType_, object_, tagName_, tagSize_, pTag_ ) + : objectType( objectType_ ) + , object( object_ ) + , tagName( tagName_ ) + , tagSize( tagSize_ ) + , pTag( pTag_ ) {} + vk::DebugMarkerObjectTagInfoEXT & operator=( vk::DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerObjectTagInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerObjectTagInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugMarkerObjectTagInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27128,61 +26068,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugMarkerObjectTagInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; + const void* pNext = nullptr; + vk::DebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; }; static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugReportCallbackCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(), - PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, - void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pfnCallback( pfnCallback_ ) - , pUserData( pUserData_ ) - {} - - DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; - const void* pNext = nullptr; - vk::DebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; - }; - static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugReportCallbackCreateInfoEXT : public layout::DebugReportCallbackCreateInfoEXT + struct DebugReportCallbackCreateInfoEXT { VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugReportCallbackCreateInfoEXT( flags_, pfnCallback_, pUserData_ ) + : flags( flags_ ) + , pfnCallback( pfnCallback_ ) + , pUserData( pUserData_ ) {} + vk::DebugReportCallbackCreateInfoEXT & operator=( vk::DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugReportCallbackCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugReportCallbackCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugReportCallbackCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27234,59 +26155,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugReportCallbackCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; + const void* pNext = nullptr; + vk::DebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; }; static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsLabelEXT - { - protected: - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr, - std::array const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : pLabelName( pLabelName_ ) - , color{} - { - vk::ConstExpressionArrayCopy::copy( color, color_ ); - } - - DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsLabelEXT; - const void* pNext = nullptr; - const char* pLabelName; - float color[4]; - }; - static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsLabelEXT : public layout::DebugUtilsLabelEXT + struct DebugUtilsLabelEXT { VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr, std::array const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsLabelEXT( pLabelName_, color_ ) - {} + : pLabelName( pLabelName_ ) + , color{} + { + vk::ConstExpressionArrayCopy::copy( color, color_ ); + } + + vk::DebugUtilsLabelEXT & operator=( vk::DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsLabelEXT ) - sizeof( vk::StructureType ) ); + return *this; + } DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsLabelEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsLabelEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27331,61 +26233,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsLabelEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsLabelEXT; + const void* pNext = nullptr; + const char* pLabelName; + float color[4]; }; static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsObjectNameInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown, - uint64_t objectHandle_ = 0, - const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT - : objectType( objectType_ ) - , objectHandle( objectHandle_ ) - , pObjectName( pObjectName_ ) - {} - - DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; - const void* pNext = nullptr; - vk::ObjectType objectType; - uint64_t objectHandle; - const char* pObjectName; - }; - static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsObjectNameInfoEXT : public layout::DebugUtilsObjectNameInfoEXT + struct DebugUtilsObjectNameInfoEXT { VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown, uint64_t objectHandle_ = 0, const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsObjectNameInfoEXT( objectType_, objectHandle_, pObjectName_ ) + : objectType( objectType_ ) + , objectHandle( objectHandle_ ) + , pObjectName( pObjectName_ ) {} + vk::DebugUtilsObjectNameInfoEXT & operator=( vk::DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsObjectNameInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsObjectNameInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsObjectNameInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27437,68 +26317,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsObjectNameInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; + const void* pNext = nullptr; + vk::ObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; }; static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsMessengerCallbackDataEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(), - const char* pMessageIdName_ = nullptr, - int32_t messageIdNumber_ = 0, - const char* pMessage_ = nullptr, - uint32_t queueLabelCount_ = 0, - const vk::DebugUtilsLabelEXT* pQueueLabels_ = nullptr, - uint32_t cmdBufLabelCount_ = 0, - const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr, - uint32_t objectCount_ = 0, - const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pMessageIdName( pMessageIdName_ ) - , messageIdNumber( messageIdNumber_ ) - , pMessage( pMessage_ ) - , queueLabelCount( queueLabelCount_ ) - , pQueueLabels( pQueueLabels_ ) - , cmdBufLabelCount( cmdBufLabelCount_ ) - , pCmdBufLabels( pCmdBufLabels_ ) - , objectCount( objectCount_ ) - , pObjects( pObjects_ ) - {} - - DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; - const void* pNext = nullptr; - vk::DebugUtilsMessengerCallbackDataFlagsEXT flags; - const char* pMessageIdName; - int32_t messageIdNumber; - const char* pMessage; - uint32_t queueLabelCount; - const vk::DebugUtilsLabelEXT* pQueueLabels; - uint32_t cmdBufLabelCount; - const vk::DebugUtilsLabelEXT* pCmdBufLabels; - uint32_t objectCount; - const vk::DebugUtilsObjectNameInfoEXT* pObjects; - }; - static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsMessengerCallbackDataEXT : public layout::DebugUtilsMessengerCallbackDataEXT + struct DebugUtilsMessengerCallbackDataEXT { VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(), const char* pMessageIdName_ = nullptr, @@ -27510,16 +26339,32 @@ namespace VULKAN_HPP_NAMESPACE const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr, uint32_t objectCount_ = 0, const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsMessengerCallbackDataEXT( flags_, pMessageIdName_, messageIdNumber_, pMessage_, queueLabelCount_, pQueueLabels_, cmdBufLabelCount_, pCmdBufLabels_, objectCount_, pObjects_ ) + : flags( flags_ ) + , pMessageIdName( pMessageIdName_ ) + , messageIdNumber( messageIdNumber_ ) + , pMessage( pMessage_ ) + , queueLabelCount( queueLabelCount_ ) + , pQueueLabels( pQueueLabels_ ) + , cmdBufLabelCount( cmdBufLabelCount_ ) + , pCmdBufLabels( pCmdBufLabels_ ) + , objectCount( objectCount_ ) + , pObjects( pObjects_ ) {} + vk::DebugUtilsMessengerCallbackDataEXT & operator=( vk::DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsMessengerCallbackDataEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsMessengerCallbackDataEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsMessengerCallbackDataEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27620,69 +26465,51 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsMessengerCallbackDataEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; + const void* pNext = nullptr; + vk::DebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + const vk::DebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + const vk::DebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + const vk::DebugUtilsObjectNameInfoEXT* pObjects; }; static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsMessengerCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(), - vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(), - vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(), - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr, - void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , messageSeverity( messageSeverity_ ) - , messageType( messageType_ ) - , pfnUserCallback( pfnUserCallback_ ) - , pUserData( pUserData_ ) - {} - - DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; - const void* pNext = nullptr; - vk::DebugUtilsMessengerCreateFlagsEXT flags; - vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity; - vk::DebugUtilsMessageTypeFlagsEXT messageType; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; - void* pUserData; - }; - static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsMessengerCreateInfoEXT : public layout::DebugUtilsMessengerCreateInfoEXT + struct DebugUtilsMessengerCreateInfoEXT { VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(), vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(), vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(), PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr, void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsMessengerCreateInfoEXT( flags_, messageSeverity_, messageType_, pfnUserCallback_, pUserData_ ) + : flags( flags_ ) + , messageSeverity( messageSeverity_ ) + , messageType( messageType_ ) + , pfnUserCallback( pfnUserCallback_ ) + , pUserData( pUserData_ ) {} + vk::DebugUtilsMessengerCreateInfoEXT & operator=( vk::DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsMessengerCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsMessengerCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsMessengerCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27748,69 +26575,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsMessengerCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; + const void* pNext = nullptr; + vk::DebugUtilsMessengerCreateFlagsEXT flags; + vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity; + vk::DebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; }; static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsObjectTagInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown, - uint64_t objectHandle_ = 0, - uint64_t tagName_ = 0, - size_t tagSize_ = 0, - const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT - : objectType( objectType_ ) - , objectHandle( objectHandle_ ) - , tagName( tagName_ ) - , tagSize( tagSize_ ) - , pTag( pTag_ ) - {} - - DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; - const void* pNext = nullptr; - vk::ObjectType objectType; - uint64_t objectHandle; - uint64_t tagName; - size_t tagSize; - const void* pTag; - }; - static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsObjectTagInfoEXT : public layout::DebugUtilsObjectTagInfoEXT + struct DebugUtilsObjectTagInfoEXT { VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown, uint64_t objectHandle_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsObjectTagInfoEXT( objectType_, objectHandle_, tagName_, tagSize_, pTag_ ) + : objectType( objectType_ ) + , objectHandle( objectHandle_ ) + , tagName( tagName_ ) + , tagSize( tagSize_ ) + , pTag( pTag_ ) {} + vk::DebugUtilsObjectTagInfoEXT & operator=( vk::DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsObjectTagInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsObjectTagInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsObjectTagInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27876,53 +26680,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsObjectTagInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; + const void* pNext = nullptr; + vk::ObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag; }; static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DedicatedAllocationBufferCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : dedicatedAllocation( dedicatedAllocation_ ) - {} - - DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 dedicatedAllocation; - }; - static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct DedicatedAllocationBufferCreateInfoNV : public layout::DedicatedAllocationBufferCreateInfoNV + struct DedicatedAllocationBufferCreateInfoNV { VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationBufferCreateInfoNV( dedicatedAllocation_ ) + : dedicatedAllocation( dedicatedAllocation_ ) {} + vk::DedicatedAllocationBufferCreateInfoNV & operator=( vk::DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationBufferCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationBufferCreateInfoNV( rhs ) - {} + { + *this = rhs; + } DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DedicatedAllocationBufferCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27960,53 +26749,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DedicatedAllocationBufferCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 dedicatedAllocation; }; static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DedicatedAllocationImageCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : dedicatedAllocation( dedicatedAllocation_ ) - {} - - DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 dedicatedAllocation; - }; - static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct DedicatedAllocationImageCreateInfoNV : public layout::DedicatedAllocationImageCreateInfoNV + struct DedicatedAllocationImageCreateInfoNV { VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationImageCreateInfoNV( dedicatedAllocation_ ) + : dedicatedAllocation( dedicatedAllocation_ ) {} + vk::DedicatedAllocationImageCreateInfoNV & operator=( vk::DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationImageCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationImageCreateInfoNV( rhs ) - {} + { + *this = rhs; + } DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DedicatedAllocationImageCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28044,57 +26814,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DedicatedAllocationImageCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 dedicatedAllocation; }; static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DedicatedAllocationMemoryAllocateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(), - vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - , buffer( buffer_ ) - {} - - DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; - const void* pNext = nullptr; - vk::Image image; - vk::Buffer buffer; - }; - static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct DedicatedAllocationMemoryAllocateInfoNV : public layout::DedicatedAllocationMemoryAllocateInfoNV + struct DedicatedAllocationMemoryAllocateInfoNV { VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(), vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationMemoryAllocateInfoNV( image_, buffer_ ) + : image( image_ ) + , buffer( buffer_ ) {} + vk::DedicatedAllocationMemoryAllocateInfoNV & operator=( vk::DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationMemoryAllocateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationMemoryAllocateInfoNV( rhs ) - {} + { + *this = rhs; + } DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DedicatedAllocationMemoryAllocateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28139,8 +26888,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DedicatedAllocationMemoryAllocateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; + const void* pNext = nullptr; + vk::Image image; + vk::Buffer buffer; }; static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -28157,12 +26909,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -28226,12 +26978,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -28293,12 +27045,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -28342,59 +27094,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorPoolCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(), - uint32_t maxSets_ = 0, - uint32_t poolSizeCount_ = 0, - const vk::DescriptorPoolSize* pPoolSizes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , maxSets( maxSets_ ) - , poolSizeCount( poolSizeCount_ ) - , pPoolSizes( pPoolSizes_ ) - {} - - DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorPoolCreateInfo; - const void* pNext = nullptr; - vk::DescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const vk::DescriptorPoolSize* pPoolSizes; - }; - static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorPoolCreateInfo : public layout::DescriptorPoolCreateInfo + struct DescriptorPoolCreateInfo { VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const vk::DescriptorPoolSize* pPoolSizes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorPoolCreateInfo( flags_, maxSets_, poolSizeCount_, pPoolSizes_ ) + : flags( flags_ ) + , maxSets( maxSets_ ) + , poolSizeCount( poolSizeCount_ ) + , pPoolSizes( pPoolSizes_ ) {} + vk::DescriptorPoolCreateInfo & operator=( vk::DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorPoolCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorPoolCreateInfo( rhs ) - {} + { + *this = rhs; + } DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorPoolCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28453,53 +27178,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorPoolCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorPoolCreateInfo; + const void* pNext = nullptr; + vk::DescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const vk::DescriptorPoolSize* pPoolSizes; }; static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorPoolInlineUniformBlockCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 ) VULKAN_HPP_NOEXCEPT - : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ ) - {} - - DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT; - const void* pNext = nullptr; - uint32_t maxInlineUniformBlockBindings; - }; - static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorPoolInlineUniformBlockCreateInfoEXT : public layout::DescriptorPoolInlineUniformBlockCreateInfoEXT + struct DescriptorPoolInlineUniformBlockCreateInfoEXT { VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( maxInlineUniformBlockBindings_ ) + : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ ) {} + vk::DescriptorPoolInlineUniformBlockCreateInfoEXT & operator=( vk::DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorPoolInlineUniformBlockCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28537,61 +27246,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT; + const void* pNext = nullptr; + uint32_t maxInlineUniformBlockBindings; }; static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorSetAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(), - uint32_t descriptorSetCount_ = 0, - const vk::DescriptorSetLayout* pSetLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : descriptorPool( descriptorPool_ ) - , descriptorSetCount( descriptorSetCount_ ) - , pSetLayouts( pSetLayouts_ ) - {} - - DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetAllocateInfo; - const void* pNext = nullptr; - vk::DescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const vk::DescriptorSetLayout* pSetLayouts; - }; - static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetAllocateInfo : public layout::DescriptorSetAllocateInfo + struct DescriptorSetAllocateInfo { VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(), uint32_t descriptorSetCount_ = 0, const vk::DescriptorSetLayout* pSetLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetAllocateInfo( descriptorPool_, descriptorSetCount_, pSetLayouts_ ) + : descriptorPool( descriptorPool_ ) + , descriptorSetCount( descriptorSetCount_ ) + , pSetLayouts( pSetLayouts_ ) {} + vk::DescriptorSetAllocateInfo & operator=( vk::DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetAllocateInfo( rhs ) - {} + { + *this = rhs; + } DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28643,8 +27329,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetAllocateInfo; + const void* pNext = nullptr; + vk::DescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const vk::DescriptorSetLayout* pSetLayouts; }; static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -28665,12 +27355,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -28738,51 +27428,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorSetLayoutBindingFlagsCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0, - const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr ) VULKAN_HPP_NOEXCEPT - : bindingCount( bindingCount_ ) - , pBindingFlags( pBindingFlags_ ) - {} - - DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT; - const void* pNext = nullptr; - uint32_t bindingCount; - const vk::DescriptorBindingFlagsEXT* pBindingFlags; - }; - static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetLayoutBindingFlagsCreateInfoEXT : public layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT + struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0, const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( bindingCount_, pBindingFlags_ ) + : bindingCount( bindingCount_ ) + , pBindingFlags( pBindingFlags_ ) {} + vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT & operator=( vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28827,61 +27494,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT; + const void* pNext = nullptr; + uint32_t bindingCount; + const vk::DescriptorBindingFlagsEXT* pBindingFlags; }; static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorSetLayoutCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(), - uint32_t bindingCount_ = 0, - const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , bindingCount( bindingCount_ ) - , pBindings( pBindings_ ) - {} - - DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; - const void* pNext = nullptr; - vk::DescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const vk::DescriptorSetLayoutBinding* pBindings; - }; - static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetLayoutCreateInfo : public layout::DescriptorSetLayoutCreateInfo + struct DescriptorSetLayoutCreateInfo { VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutCreateInfo( flags_, bindingCount_, pBindings_ ) + : flags( flags_ ) + , bindingCount( bindingCount_ ) + , pBindings( pBindings_ ) {} + vk::DescriptorSetLayoutCreateInfo & operator=( vk::DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutCreateInfo( rhs ) - {} + { + *this = rhs; + } DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetLayoutCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28933,52 +27578,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetLayoutCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; + const void* pNext = nullptr; + vk::DescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const vk::DescriptorSetLayoutBinding* pBindings; }; static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DescriptorSetLayoutSupport { - struct DescriptorSetLayoutSupport - { - protected: - DescriptorSetLayoutSupport() VULKAN_HPP_NOEXCEPT - {} - - DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetLayoutSupport; - void* pNext = nullptr; - vk::Bool32 supported; - }; - static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetLayoutSupport : public layout::DescriptorSetLayoutSupport - { - DescriptorSetLayoutSupport() VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutSupport() + DescriptorSetLayoutSupport( vk::Bool32 supported_ = 0 ) VULKAN_HPP_NOEXCEPT + : supported( supported_ ) {} + vk::DescriptorSetLayoutSupport & operator=( vk::DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutSupport ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutSupport( rhs ) - {} + { + *this = rhs; + } DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetLayoutSupport::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29004,57 +27633,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetLayoutSupport::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetLayoutSupport; + void* pNext = nullptr; + vk::Bool32 supported; }; static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorSetVariableDescriptorCountAllocateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0, - const uint32_t* pDescriptorCounts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : descriptorSetCount( descriptorSetCount_ ) - , pDescriptorCounts( pDescriptorCounts_ ) - {} - - DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT; - const void* pNext = nullptr; - uint32_t descriptorSetCount; - const uint32_t* pDescriptorCounts; - }; - static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetVariableDescriptorCountAllocateInfoEXT : public layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT + struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0, const uint32_t* pDescriptorCounts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( descriptorSetCount_, pDescriptorCounts_ ) + : descriptorSetCount( descriptorSetCount_ ) + , pDescriptorCounts( pDescriptorCounts_ ) {} + vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT & operator=( vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( rhs ) - {} + { + *this = rhs; + } DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29099,52 +27707,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT; + const void* pNext = nullptr; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; }; static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { - struct DescriptorSetVariableDescriptorCountLayoutSupportEXT - { - protected: - DescriptorSetVariableDescriptorCountLayoutSupportEXT() VULKAN_HPP_NOEXCEPT - {} - - DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT; - void* pNext = nullptr; - uint32_t maxVariableDescriptorCount; - }; - static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetVariableDescriptorCountLayoutSupportEXT : public layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT - { - DescriptorSetVariableDescriptorCountLayoutSupportEXT() VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT() + DescriptorSetVariableDescriptorCountLayoutSupportEXT( uint32_t maxVariableDescriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxVariableDescriptorCount( maxVariableDescriptorCount_ ) {} + vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT & operator=( vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT( rhs ) - {} + { + *this = rhs; + } DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29170,8 +27761,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT; + void* pNext = nullptr; + uint32_t maxVariableDescriptorCount; }; static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -29194,12 +27787,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -29275,56 +27868,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorUpdateTemplateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(), - uint32_t descriptorUpdateEntryCount_ = 0, - const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr, - vk::DescriptorUpdateTemplateType templateType_ = vk::DescriptorUpdateTemplateType::eDescriptorSet, - vk::DescriptorSetLayout descriptorSetLayout_ = vk::DescriptorSetLayout(), - vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, - vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(), - uint32_t set_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) - , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) - , templateType( templateType_ ) - , descriptorSetLayout( descriptorSetLayout_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , pipelineLayout( pipelineLayout_ ) - , set( set_ ) - {} - - DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; - const void* pNext = nullptr; - vk::DescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; - vk::DescriptorUpdateTemplateType templateType; - vk::DescriptorSetLayout descriptorSetLayout; - vk::PipelineBindPoint pipelineBindPoint; - vk::PipelineLayout pipelineLayout; - uint32_t set; - }; - static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorUpdateTemplateCreateInfo : public layout::DescriptorUpdateTemplateCreateInfo + struct DescriptorUpdateTemplateCreateInfo { VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(), uint32_t descriptorUpdateEntryCount_ = 0, @@ -29334,16 +27878,30 @@ namespace VULKAN_HPP_NAMESPACE vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(), uint32_t set_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorUpdateTemplateCreateInfo( flags_, descriptorUpdateEntryCount_, pDescriptorUpdateEntries_, templateType_, descriptorSetLayout_, pipelineBindPoint_, pipelineLayout_, set_ ) + : flags( flags_ ) + , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) + , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) + , templateType( templateType_ ) + , descriptorSetLayout( descriptorSetLayout_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , pipelineLayout( pipelineLayout_ ) + , set( set_ ) {} + vk::DescriptorUpdateTemplateCreateInfo & operator=( vk::DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorUpdateTemplateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorUpdateTemplateCreateInfo( rhs ) - {} + { + *this = rhs; + } DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorUpdateTemplateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29430,65 +27988,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorUpdateTemplateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; + const void* pNext = nullptr; + vk::DescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + vk::DescriptorUpdateTemplateType templateType; + vk::DescriptorSetLayout descriptorSetLayout; + vk::PipelineBindPoint pipelineBindPoint; + vk::PipelineLayout pipelineLayout; + uint32_t set; }; static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceQueueCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(), - uint32_t queueFamilyIndex_ = 0, - uint32_t queueCount_ = 0, - const float* pQueuePriorities_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , queueCount( queueCount_ ) - , pQueuePriorities( pQueuePriorities_ ) - {} - - DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceQueueCreateInfo; - const void* pNext = nullptr; - vk::DeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - const float* pQueuePriorities; - }; - static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceQueueCreateInfo : public layout::DeviceQueueCreateInfo + struct DeviceQueueCreateInfo { VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueCount_ = 0, const float* pQueuePriorities_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueCreateInfo( flags_, queueFamilyIndex_, queueCount_, pQueuePriorities_ ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + , queueCount( queueCount_ ) + , pQueuePriorities( pQueuePriorities_ ) {} + vk::DeviceQueueCreateInfo & operator=( vk::DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueCreateInfo( rhs ) - {} + { + *this = rhs; + } DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceQueueCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29547,8 +28087,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceQueueCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceQueueCreateInfo; + const void* pNext = nullptr; + vk::DeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; }; static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -29669,12 +28214,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -30142,56 +28687,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(), - uint32_t queueCreateInfoCount_ = 0, - const vk::DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, - uint32_t enabledLayerCount_ = 0, - const char* const* ppEnabledLayerNames_ = nullptr, - uint32_t enabledExtensionCount_ = 0, - const char* const* ppEnabledExtensionNames_ = nullptr, - const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queueCreateInfoCount( queueCreateInfoCount_ ) - , pQueueCreateInfos( pQueueCreateInfos_ ) - , enabledLayerCount( enabledLayerCount_ ) - , ppEnabledLayerNames( ppEnabledLayerNames_ ) - , enabledExtensionCount( enabledExtensionCount_ ) - , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) - , pEnabledFeatures( pEnabledFeatures_ ) - {} - - DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceCreateInfo; - const void* pNext = nullptr; - vk::DeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const vk::DeviceQueueCreateInfo* pQueueCreateInfos; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - const vk::PhysicalDeviceFeatures* pEnabledFeatures; - }; - static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceCreateInfo : public layout::DeviceCreateInfo + struct DeviceCreateInfo { VULKAN_HPP_CONSTEXPR DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(), uint32_t queueCreateInfoCount_ = 0, @@ -30201,16 +28697,30 @@ namespace VULKAN_HPP_NAMESPACE uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr, const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceCreateInfo( flags_, queueCreateInfoCount_, pQueueCreateInfos_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_, pEnabledFeatures_ ) + : flags( flags_ ) + , queueCreateInfoCount( queueCreateInfoCount_ ) + , pQueueCreateInfos( pQueueCreateInfos_ ) + , enabledLayerCount( enabledLayerCount_ ) + , ppEnabledLayerNames( ppEnabledLayerNames_ ) + , enabledExtensionCount( enabledExtensionCount_ ) + , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) + , pEnabledFeatures( pEnabledFeatures_ ) {} + vk::DeviceCreateInfo & operator=( vk::DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceCreateInfo( rhs ) - {} + { + *this = rhs; + } DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30297,53 +28807,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceCreateInfo; + const void* pNext = nullptr; + vk::DeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const vk::DeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const vk::PhysicalDeviceFeatures* pEnabledFeatures; }; static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceEventInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT - : deviceEvent( deviceEvent_ ) - {} - - DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceEventInfoEXT; - const void* pNext = nullptr; - vk::DeviceEventTypeEXT deviceEvent; - }; - static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DeviceEventInfoEXT : public layout::DeviceEventInfoEXT + struct DeviceEventInfoEXT { VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT - : layout::DeviceEventInfoEXT( deviceEvent_ ) + : deviceEvent( deviceEvent_ ) {} + vk::DeviceEventInfoEXT & operator=( vk::DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceEventInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceEventInfoEXT( rhs ) - {} + { + *this = rhs; + } DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceEventInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30381,53 +28879,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceEventInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDeviceEventInfoEXT; + const void* pNext = nullptr; + vk::DeviceEventTypeEXT deviceEvent; }; static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGeneratedCommandsFeaturesNVX - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 ) VULKAN_HPP_NOEXCEPT - : computeBindingPointSupport( computeBindingPointSupport_ ) - {} - - DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX; - const void* pNext = nullptr; - vk::Bool32 computeBindingPointSupport; - }; - static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGeneratedCommandsFeaturesNVX : public layout::DeviceGeneratedCommandsFeaturesNVX + struct DeviceGeneratedCommandsFeaturesNVX { VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGeneratedCommandsFeaturesNVX( computeBindingPointSupport_ ) + : computeBindingPointSupport( computeBindingPointSupport_ ) {} + vk::DeviceGeneratedCommandsFeaturesNVX & operator=( vk::DeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGeneratedCommandsFeaturesNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGeneratedCommandsFeaturesNVX( rhs ) - {} + { + *this = rhs; + } DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGeneratedCommandsFeaturesNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30465,69 +28944,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGeneratedCommandsFeaturesNVX::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX; + const void* pNext = nullptr; + vk::Bool32 computeBindingPointSupport; }; static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGeneratedCommandsLimitsNVX - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, - uint32_t maxObjectEntryCounts_ = 0, - uint32_t minSequenceCountBufferOffsetAlignment_ = 0, - uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, - uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT - : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) - , maxObjectEntryCounts( maxObjectEntryCounts_ ) - , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ ) - , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ ) - , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ ) - {} - - DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX; - const void* pNext = nullptr; - uint32_t maxIndirectCommandsLayoutTokenCount; - uint32_t maxObjectEntryCounts; - uint32_t minSequenceCountBufferOffsetAlignment; - uint32_t minSequenceIndexBufferOffsetAlignment; - uint32_t minCommandsTokenBufferOffsetAlignment; - }; - static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGeneratedCommandsLimitsNVX : public layout::DeviceGeneratedCommandsLimitsNVX + struct DeviceGeneratedCommandsLimitsNVX { VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, uint32_t maxObjectEntryCounts_ = 0, uint32_t minSequenceCountBufferOffsetAlignment_ = 0, uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGeneratedCommandsLimitsNVX( maxIndirectCommandsLayoutTokenCount_, maxObjectEntryCounts_, minSequenceCountBufferOffsetAlignment_, minSequenceIndexBufferOffsetAlignment_, minCommandsTokenBufferOffsetAlignment_ ) + : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) + , maxObjectEntryCounts( maxObjectEntryCounts_ ) + , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ ) + , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ ) + , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ ) {} + vk::DeviceGeneratedCommandsLimitsNVX & operator=( vk::DeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGeneratedCommandsLimitsNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGeneratedCommandsLimitsNVX( rhs ) - {} + { + *this = rhs; + } DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGeneratedCommandsLimitsNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30593,57 +29045,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGeneratedCommandsLimitsNVX::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX; + const void* pNext = nullptr; + uint32_t maxIndirectCommandsLayoutTokenCount; + uint32_t maxObjectEntryCounts; + uint32_t minSequenceCountBufferOffsetAlignment; + uint32_t minSequenceIndexBufferOffsetAlignment; + uint32_t minCommandsTokenBufferOffsetAlignment; }; static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupBindSparseInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0, - uint32_t memoryDeviceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : resourceDeviceIndex( resourceDeviceIndex_ ) - , memoryDeviceIndex( memoryDeviceIndex_ ) - {} - - DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupBindSparseInfo; - const void* pNext = nullptr; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; - }; - static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupBindSparseInfo : public layout::DeviceGroupBindSparseInfo + struct DeviceGroupBindSparseInfo { VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0, uint32_t memoryDeviceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupBindSparseInfo( resourceDeviceIndex_, memoryDeviceIndex_ ) + : resourceDeviceIndex( resourceDeviceIndex_ ) + , memoryDeviceIndex( memoryDeviceIndex_ ) {} + vk::DeviceGroupBindSparseInfo & operator=( vk::DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupBindSparseInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupBindSparseInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupBindSparseInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30688,53 +29123,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupBindSparseInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupBindSparseInfo; + const void* pNext = nullptr; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; }; static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupCommandBufferBeginInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : deviceMask( deviceMask_ ) - {} - - DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; - const void* pNext = nullptr; - uint32_t deviceMask; - }; - static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupCommandBufferBeginInfo : public layout::DeviceGroupCommandBufferBeginInfo + struct DeviceGroupCommandBufferBeginInfo { VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupCommandBufferBeginInfo( deviceMask_ ) + : deviceMask( deviceMask_ ) {} + vk::DeviceGroupCommandBufferBeginInfo & operator=( vk::DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupCommandBufferBeginInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupCommandBufferBeginInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupCommandBufferBeginInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30772,57 +29189,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupCommandBufferBeginInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; + const void* pNext = nullptr; + uint32_t deviceMask; }; static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupDeviceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0, - const vk::PhysicalDevice* pPhysicalDevices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : physicalDeviceCount( physicalDeviceCount_ ) - , pPhysicalDevices( pPhysicalDevices_ ) - {} - - DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; - const void* pNext = nullptr; - uint32_t physicalDeviceCount; - const vk::PhysicalDevice* pPhysicalDevices; - }; - static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupDeviceCreateInfo : public layout::DeviceGroupDeviceCreateInfo + struct DeviceGroupDeviceCreateInfo { VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0, const vk::PhysicalDevice* pPhysicalDevices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupDeviceCreateInfo( physicalDeviceCount_, pPhysicalDevices_ ) + : physicalDeviceCount( physicalDeviceCount_ ) + , pPhysicalDevices( pPhysicalDevices_ ) {} + vk::DeviceGroupDeviceCreateInfo & operator=( vk::DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupDeviceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupDeviceCreateInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupDeviceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30867,53 +29263,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupDeviceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; + const void* pNext = nullptr; + uint32_t physicalDeviceCount; + const vk::PhysicalDevice* pPhysicalDevices; }; static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DeviceGroupPresentCapabilitiesKHR { - struct DeviceGroupPresentCapabilitiesKHR + DeviceGroupPresentCapabilitiesKHR( std::array const& presentMask_ = { { 0 } }, + vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT + : presentMask{} + , modes( modes_ ) { - protected: - DeviceGroupPresentCapabilitiesKHR() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( presentMask, presentMask_ ); + } - DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; - const void* pNext = nullptr; - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; - vk::DeviceGroupPresentModeFlagsKHR modes; - }; - static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupPresentCapabilitiesKHR : public layout::DeviceGroupPresentCapabilitiesKHR - { - DeviceGroupPresentCapabilitiesKHR() VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupPresentCapabilitiesKHR() - {} + vk::DeviceGroupPresentCapabilitiesKHR & operator=( vk::DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupPresentCapabilitiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupPresentCapabilitiesKHR( rhs ) - {} + { + *this = rhs; + } DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupPresentCapabilitiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30940,61 +29322,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupPresentCapabilitiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; + const void* pNext = nullptr; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + vk::DeviceGroupPresentModeFlagsKHR modes; }; static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupPresentInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0, - const uint32_t* pDeviceMasks_ = nullptr, - vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal ) VULKAN_HPP_NOEXCEPT - : swapchainCount( swapchainCount_ ) - , pDeviceMasks( pDeviceMasks_ ) - , mode( mode_ ) - {} - - DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; - const void* pNext = nullptr; - uint32_t swapchainCount; - const uint32_t* pDeviceMasks; - vk::DeviceGroupPresentModeFlagBitsKHR mode; - }; - static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupPresentInfoKHR : public layout::DeviceGroupPresentInfoKHR + struct DeviceGroupPresentInfoKHR { VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0, const uint32_t* pDeviceMasks_ = nullptr, vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupPresentInfoKHR( swapchainCount_, pDeviceMasks_, mode_ ) + : swapchainCount( swapchainCount_ ) + , pDeviceMasks( pDeviceMasks_ ) + , mode( mode_ ) {} + vk::DeviceGroupPresentInfoKHR & operator=( vk::DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupPresentInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupPresentInfoKHR( rhs ) - {} + { + *this = rhs; + } DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupPresentInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31046,61 +29406,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupPresentInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; + const void* pNext = nullptr; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + vk::DeviceGroupPresentModeFlagBitsKHR mode; }; static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupRenderPassBeginInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0, - uint32_t deviceRenderAreaCount_ = 0, - const vk::Rect2D* pDeviceRenderAreas_ = nullptr ) VULKAN_HPP_NOEXCEPT - : deviceMask( deviceMask_ ) - , deviceRenderAreaCount( deviceRenderAreaCount_ ) - , pDeviceRenderAreas( pDeviceRenderAreas_ ) - {} - - DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; - const void* pNext = nullptr; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const vk::Rect2D* pDeviceRenderAreas; - }; - static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupRenderPassBeginInfo : public layout::DeviceGroupRenderPassBeginInfo + struct DeviceGroupRenderPassBeginInfo { VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0, uint32_t deviceRenderAreaCount_ = 0, const vk::Rect2D* pDeviceRenderAreas_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupRenderPassBeginInfo( deviceMask_, deviceRenderAreaCount_, pDeviceRenderAreas_ ) + : deviceMask( deviceMask_ ) + , deviceRenderAreaCount( deviceRenderAreaCount_ ) + , pDeviceRenderAreas( pDeviceRenderAreas_ ) {} + vk::DeviceGroupRenderPassBeginInfo & operator=( vk::DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupRenderPassBeginInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupRenderPassBeginInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupRenderPassBeginInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31152,56 +29491,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupRenderPassBeginInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; + const void* pNext = nullptr; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const vk::Rect2D* pDeviceRenderAreas; }; static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupSubmitInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0, - const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, - uint32_t commandBufferCount_ = 0, - const uint32_t* pCommandBufferDeviceMasks_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ) - , commandBufferCount( commandBufferCount_ ) - , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ ) - {} - - DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupSubmitInfo; - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const uint32_t* pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - const uint32_t* pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - const uint32_t* pSignalSemaphoreDeviceIndices; - }; - static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupSubmitInfo : public layout::DeviceGroupSubmitInfo + struct DeviceGroupSubmitInfo { VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0, const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, @@ -31209,16 +29509,28 @@ namespace VULKAN_HPP_NAMESPACE const uint32_t* pCommandBufferDeviceMasks_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupSubmitInfo( waitSemaphoreCount_, pWaitSemaphoreDeviceIndices_, commandBufferCount_, pCommandBufferDeviceMasks_, signalSemaphoreCount_, pSignalSemaphoreDeviceIndices_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ) + , commandBufferCount( commandBufferCount_ ) + , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ ) {} + vk::DeviceGroupSubmitInfo & operator=( vk::DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupSubmitInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupSubmitInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupSubmitInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31291,53 +29603,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupSubmitInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupSubmitInfo; + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; }; static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupSwapchainCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT - : modes( modes_ ) - {} - - DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; - const void* pNext = nullptr; - vk::DeviceGroupPresentModeFlagsKHR modes; - }; - static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupSwapchainCreateInfoKHR : public layout::DeviceGroupSwapchainCreateInfoKHR + struct DeviceGroupSwapchainCreateInfoKHR { VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupSwapchainCreateInfoKHR( modes_ ) + : modes( modes_ ) {} + vk::DeviceGroupSwapchainCreateInfoKHR & operator=( vk::DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupSwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupSwapchainCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupSwapchainCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31375,53 +29673,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupSwapchainCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; + const void* pNext = nullptr; + vk::DeviceGroupPresentModeFlagsKHR modes; }; static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceMemoryOverallocationCreateInfoAMD - { - protected: - VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT - : overallocationBehavior( overallocationBehavior_ ) - {} - - DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; - const void* pNext = nullptr; - vk::MemoryOverallocationBehaviorAMD overallocationBehavior; - }; - static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "layout struct and wrapper have different size!" ); - } - - struct DeviceMemoryOverallocationCreateInfoAMD : public layout::DeviceMemoryOverallocationCreateInfoAMD + struct DeviceMemoryOverallocationCreateInfoAMD { VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT - : layout::DeviceMemoryOverallocationCreateInfoAMD( overallocationBehavior_ ) + : overallocationBehavior( overallocationBehavior_ ) {} + vk::DeviceMemoryOverallocationCreateInfoAMD & operator=( vk::DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceMemoryOverallocationCreateInfoAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceMemoryOverallocationCreateInfoAMD( rhs ) - {} + { + *this = rhs; + } DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceMemoryOverallocationCreateInfoAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31459,53 +29738,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceMemoryOverallocationCreateInfoAMD::sType; + public: + const vk::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; + const void* pNext = nullptr; + vk::MemoryOverallocationBehaviorAMD overallocationBehavior; }; static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceQueueGlobalPriorityCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT - : globalPriority( globalPriority_ ) - {} - - DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; - const void* pNext = nullptr; - vk::QueueGlobalPriorityEXT globalPriority; - }; - static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DeviceQueueGlobalPriorityCreateInfoEXT : public layout::DeviceQueueGlobalPriorityCreateInfoEXT + struct DeviceQueueGlobalPriorityCreateInfoEXT { VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueGlobalPriorityCreateInfoEXT( globalPriority_ ) + : globalPriority( globalPriority_ ) {} + vk::DeviceQueueGlobalPriorityCreateInfoEXT & operator=( vk::DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueGlobalPriorityCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueGlobalPriorityCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceQueueGlobalPriorityCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31543,61 +29803,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceQueueGlobalPriorityCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; + const void* pNext = nullptr; + vk::QueueGlobalPriorityEXT globalPriority; }; static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceQueueInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(), - uint32_t queueFamilyIndex_ = 0, - uint32_t queueIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , queueIndex( queueIndex_ ) - {} - - DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceQueueInfo2; - const void* pNext = nullptr; - vk::DeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueIndex; - }; - static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct DeviceQueueInfo2 : public layout::DeviceQueueInfo2 + struct DeviceQueueInfo2 { VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueInfo2( flags_, queueFamilyIndex_, queueIndex_ ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + , queueIndex( queueIndex_ ) {} + vk::DeviceQueueInfo2 & operator=( vk::DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueInfo2( rhs ) - {} + { + *this = rhs; + } DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceQueueInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31649,8 +29886,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceQueueInfo2::sType; + public: + const vk::StructureType sType = StructureType::eDeviceQueueInfo2; + const void* pNext = nullptr; + vk::DeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; }; static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -31667,12 +29908,12 @@ namespace VULKAN_HPP_NAMESPACE DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -31724,47 +29965,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayEventInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT - : displayEvent( displayEvent_ ) - {} - - DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayEventInfoEXT; - const void* pNext = nullptr; - vk::DisplayEventTypeEXT displayEvent; - }; - static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DisplayEventInfoEXT : public layout::DisplayEventInfoEXT + struct DisplayEventInfoEXT { VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT - : layout::DisplayEventInfoEXT( displayEvent_ ) + : displayEvent( displayEvent_ ) {} + vk::DisplayEventInfoEXT & operator=( vk::DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayEventInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayEventInfoEXT( rhs ) - {} + { + *this = rhs; + } DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayEventInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31802,8 +30022,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayEventInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDisplayEventInfoEXT; + const void* pNext = nullptr; + vk::DisplayEventTypeEXT displayEvent; }; static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -31818,12 +30040,12 @@ namespace VULKAN_HPP_NAMESPACE DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -31867,51 +30089,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayModeCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(), - vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , parameters( parameters_ ) - {} - - DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayModeCreateInfoKHR; - const void* pNext = nullptr; - vk::DisplayModeCreateFlagsKHR flags; - vk::DisplayModeParametersKHR parameters; - }; - static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayModeCreateInfoKHR : public layout::DisplayModeCreateInfoKHR + struct DisplayModeCreateInfoKHR { VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(), vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT - : layout::DisplayModeCreateInfoKHR( flags_, parameters_ ) + : flags( flags_ ) + , parameters( parameters_ ) {} + vk::DisplayModeCreateInfoKHR & operator=( vk::DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayModeCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayModeCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayModeCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31956,25 +30155,31 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayModeCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayModeCreateInfoKHR; + const void* pNext = nullptr; + vk::DisplayModeCreateFlagsKHR flags; + vk::DisplayModeParametersKHR parameters; }; static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct DisplayModePropertiesKHR { - DisplayModePropertiesKHR() VULKAN_HPP_NOEXCEPT + DisplayModePropertiesKHR( vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(), + vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT + : displayMode( displayMode_ ) + , parameters( parameters_ ) {} DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayModePropertiesKHR& operator=( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32006,46 +30211,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayModeProperties2KHR { - struct DisplayModeProperties2KHR - { - protected: - DisplayModeProperties2KHR() VULKAN_HPP_NOEXCEPT - {} - - DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayModeProperties2KHR; - void* pNext = nullptr; - vk::DisplayModePropertiesKHR displayModeProperties; - }; - static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayModeProperties2KHR : public layout::DisplayModeProperties2KHR - { - DisplayModeProperties2KHR() VULKAN_HPP_NOEXCEPT - : layout::DisplayModeProperties2KHR() + DisplayModeProperties2KHR( vk::DisplayModePropertiesKHR displayModeProperties_ = vk::DisplayModePropertiesKHR() ) VULKAN_HPP_NOEXCEPT + : displayModeProperties( displayModeProperties_ ) {} + vk::DisplayModeProperties2KHR & operator=( vk::DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayModeProperties2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayModeProperties2KHR( rhs ) - {} + { + *this = rhs; + } DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayModeProperties2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32071,52 +30256,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayModeProperties2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayModeProperties2KHR; + void* pNext = nullptr; + vk::DisplayModePropertiesKHR displayModeProperties; }; static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayNativeHdrSurfaceCapabilitiesAMD { - struct DisplayNativeHdrSurfaceCapabilitiesAMD - { - protected: - DisplayNativeHdrSurfaceCapabilitiesAMD() VULKAN_HPP_NOEXCEPT - {} - - DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; - void* pNext = nullptr; - vk::Bool32 localDimmingSupport; - }; - static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "layout struct and wrapper have different size!" ); - } - - struct DisplayNativeHdrSurfaceCapabilitiesAMD : public layout::DisplayNativeHdrSurfaceCapabilitiesAMD - { - DisplayNativeHdrSurfaceCapabilitiesAMD() VULKAN_HPP_NOEXCEPT - : layout::DisplayNativeHdrSurfaceCapabilitiesAMD() + DisplayNativeHdrSurfaceCapabilitiesAMD( vk::Bool32 localDimmingSupport_ = 0 ) VULKAN_HPP_NOEXCEPT + : localDimmingSupport( localDimmingSupport_ ) {} + vk::DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( vk::DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayNativeHdrSurfaceCapabilitiesAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayNativeHdrSurfaceCapabilitiesAMD( rhs ) - {} + { + *this = rhs; + } DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayNativeHdrSurfaceCapabilitiesAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32142,25 +30309,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayNativeHdrSurfaceCapabilitiesAMD::sType; + public: + const vk::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; + void* pNext = nullptr; + vk::Bool32 localDimmingSupport; }; static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct DisplayPlaneCapabilitiesKHR { - DisplayPlaneCapabilitiesKHR() VULKAN_HPP_NOEXCEPT + DisplayPlaneCapabilitiesKHR( vk::DisplayPlaneAlphaFlagsKHR supportedAlpha_ = vk::DisplayPlaneAlphaFlagsKHR(), + vk::Offset2D minSrcPosition_ = vk::Offset2D(), + vk::Offset2D maxSrcPosition_ = vk::Offset2D(), + vk::Extent2D minSrcExtent_ = vk::Extent2D(), + vk::Extent2D maxSrcExtent_ = vk::Extent2D(), + vk::Offset2D minDstPosition_ = vk::Offset2D(), + vk::Offset2D maxDstPosition_ = vk::Offset2D(), + vk::Extent2D minDstExtent_ = vk::Extent2D(), + vk::Extent2D maxDstExtent_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT + : supportedAlpha( supportedAlpha_ ) + , minSrcPosition( minSrcPosition_ ) + , maxSrcPosition( maxSrcPosition_ ) + , minSrcExtent( minSrcExtent_ ) + , maxSrcExtent( maxSrcExtent_ ) + , minDstPosition( minDstPosition_ ) + , maxDstPosition( maxDstPosition_ ) + , minDstExtent( minDstExtent_ ) + , maxDstExtent( maxDstExtent_ ) {} DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayPlaneCapabilitiesKHR& operator=( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32206,46 +30392,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayPlaneCapabilities2KHR { - struct DisplayPlaneCapabilities2KHR - { - protected: - DisplayPlaneCapabilities2KHR() VULKAN_HPP_NOEXCEPT - {} - - DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; - void* pNext = nullptr; - vk::DisplayPlaneCapabilitiesKHR capabilities; - }; - static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPlaneCapabilities2KHR : public layout::DisplayPlaneCapabilities2KHR - { - DisplayPlaneCapabilities2KHR() VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneCapabilities2KHR() + DisplayPlaneCapabilities2KHR( vk::DisplayPlaneCapabilitiesKHR capabilities_ = vk::DisplayPlaneCapabilitiesKHR() ) VULKAN_HPP_NOEXCEPT + : capabilities( capabilities_ ) {} + vk::DisplayPlaneCapabilities2KHR & operator=( vk::DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneCapabilities2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneCapabilities2KHR( rhs ) - {} + { + *this = rhs; + } DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPlaneCapabilities2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32271,57 +30437,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPlaneCapabilities2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; + void* pNext = nullptr; + vk::DisplayPlaneCapabilitiesKHR capabilities; }; static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayPlaneInfo2KHR - { - protected: - VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(), - uint32_t planeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : mode( mode_ ) - , planeIndex( planeIndex_ ) - {} - - DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPlaneInfo2KHR; - const void* pNext = nullptr; - vk::DisplayModeKHR mode; - uint32_t planeIndex; - }; - static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPlaneInfo2KHR : public layout::DisplayPlaneInfo2KHR + struct DisplayPlaneInfo2KHR { VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(), uint32_t planeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneInfo2KHR( mode_, planeIndex_ ) + : mode( mode_ ) + , planeIndex( planeIndex_ ) {} + vk::DisplayPlaneInfo2KHR & operator=( vk::DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneInfo2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneInfo2KHR( rhs ) - {} + { + *this = rhs; + } DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPlaneInfo2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32366,25 +30511,31 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPlaneInfo2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPlaneInfo2KHR; + const void* pNext = nullptr; + vk::DisplayModeKHR mode; + uint32_t planeIndex; }; static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct DisplayPlanePropertiesKHR { - DisplayPlanePropertiesKHR() VULKAN_HPP_NOEXCEPT + DisplayPlanePropertiesKHR( vk::DisplayKHR currentDisplay_ = vk::DisplayKHR(), + uint32_t currentStackIndex_ = 0 ) VULKAN_HPP_NOEXCEPT + : currentDisplay( currentDisplay_ ) + , currentStackIndex( currentStackIndex_ ) {} DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayPlanePropertiesKHR& operator=( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32416,46 +30567,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayPlaneProperties2KHR { - struct DisplayPlaneProperties2KHR - { - protected: - DisplayPlaneProperties2KHR() VULKAN_HPP_NOEXCEPT - {} - - DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPlaneProperties2KHR; - void* pNext = nullptr; - vk::DisplayPlanePropertiesKHR displayPlaneProperties; - }; - static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPlaneProperties2KHR : public layout::DisplayPlaneProperties2KHR - { - DisplayPlaneProperties2KHR() VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneProperties2KHR() + DisplayPlaneProperties2KHR( vk::DisplayPlanePropertiesKHR displayPlaneProperties_ = vk::DisplayPlanePropertiesKHR() ) VULKAN_HPP_NOEXCEPT + : displayPlaneProperties( displayPlaneProperties_ ) {} + vk::DisplayPlaneProperties2KHR & operator=( vk::DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneProperties2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneProperties2KHR( rhs ) - {} + { + *this = rhs; + } DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPlaneProperties2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32481,53 +30612,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPlaneProperties2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPlaneProperties2KHR; + void* pNext = nullptr; + vk::DisplayPlanePropertiesKHR displayPlaneProperties; }; static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayPowerInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT - : powerState( powerState_ ) - {} - - DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPowerInfoEXT; - const void* pNext = nullptr; - vk::DisplayPowerStateEXT powerState; - }; - static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPowerInfoEXT : public layout::DisplayPowerInfoEXT + struct DisplayPowerInfoEXT { VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPowerInfoEXT( powerState_ ) + : powerState( powerState_ ) {} + vk::DisplayPowerInfoEXT & operator=( vk::DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPowerInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPowerInfoEXT( rhs ) - {} + { + *this = rhs; + } DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPowerInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32565,61 +30677,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPowerInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPowerInfoEXT; + const void* pNext = nullptr; + vk::DisplayPowerStateEXT powerState; }; static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayPresentInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(), - vk::Rect2D dstRect_ = vk::Rect2D(), - vk::Bool32 persistent_ = 0 ) VULKAN_HPP_NOEXCEPT - : srcRect( srcRect_ ) - , dstRect( dstRect_ ) - , persistent( persistent_ ) - {} - - DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPresentInfoKHR; - const void* pNext = nullptr; - vk::Rect2D srcRect; - vk::Rect2D dstRect; - vk::Bool32 persistent; - }; - static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPresentInfoKHR : public layout::DisplayPresentInfoKHR + struct DisplayPresentInfoKHR { VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(), vk::Rect2D dstRect_ = vk::Rect2D(), vk::Bool32 persistent_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPresentInfoKHR( srcRect_, dstRect_, persistent_ ) + : srcRect( srcRect_ ) + , dstRect( dstRect_ ) + , persistent( persistent_ ) {} + vk::DisplayPresentInfoKHR & operator=( vk::DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPresentInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPresentInfoKHR( rhs ) - {} + { + *this = rhs; + } DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPresentInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32671,25 +30760,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPresentInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPresentInfoKHR; + const void* pNext = nullptr; + vk::Rect2D srcRect; + vk::Rect2D dstRect; + vk::Bool32 persistent; }; static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct DisplayPropertiesKHR { - DisplayPropertiesKHR() VULKAN_HPP_NOEXCEPT + DisplayPropertiesKHR( vk::DisplayKHR display_ = vk::DisplayKHR(), + const char* displayName_ = nullptr, + vk::Extent2D physicalDimensions_ = vk::Extent2D(), + vk::Extent2D physicalResolution_ = vk::Extent2D(), + vk::SurfaceTransformFlagsKHR supportedTransforms_ = vk::SurfaceTransformFlagsKHR(), + vk::Bool32 planeReorderPossible_ = 0, + vk::Bool32 persistentContent_ = 0 ) VULKAN_HPP_NOEXCEPT + : display( display_ ) + , displayName( displayName_ ) + , physicalDimensions( physicalDimensions_ ) + , physicalResolution( physicalResolution_ ) + , supportedTransforms( supportedTransforms_ ) + , planeReorderPossible( planeReorderPossible_ ) + , persistentContent( persistentContent_ ) {} DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayPropertiesKHR& operator=( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32731,46 +30837,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayProperties2KHR { - struct DisplayProperties2KHR - { - protected: - DisplayProperties2KHR() VULKAN_HPP_NOEXCEPT - {} - - DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayProperties2KHR; - void* pNext = nullptr; - vk::DisplayPropertiesKHR displayProperties; - }; - static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayProperties2KHR : public layout::DisplayProperties2KHR - { - DisplayProperties2KHR() VULKAN_HPP_NOEXCEPT - : layout::DisplayProperties2KHR() + DisplayProperties2KHR( vk::DisplayPropertiesKHR displayProperties_ = vk::DisplayPropertiesKHR() ) VULKAN_HPP_NOEXCEPT + : displayProperties( displayProperties_ ) {} + vk::DisplayProperties2KHR & operator=( vk::DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayProperties2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayProperties2KHR( rhs ) - {} + { + *this = rhs; + } DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayProperties2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32796,62 +30882,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayProperties2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayProperties2KHR; + void* pNext = nullptr; + vk::DisplayPropertiesKHR displayProperties; }; static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplaySurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(), - vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(), - uint32_t planeIndex_ = 0, - uint32_t planeStackIndex_ = 0, - vk::SurfaceTransformFlagBitsKHR transform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity, - float globalAlpha_ = 0, - vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque, - vk::Extent2D imageExtent_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , displayMode( displayMode_ ) - , planeIndex( planeIndex_ ) - , planeStackIndex( planeStackIndex_ ) - , transform( transform_ ) - , globalAlpha( globalAlpha_ ) - , alphaMode( alphaMode_ ) - , imageExtent( imageExtent_ ) - {} - - DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::DisplaySurfaceCreateFlagsKHR flags; - vk::DisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - vk::SurfaceTransformFlagBitsKHR transform; - float globalAlpha; - vk::DisplayPlaneAlphaFlagBitsKHR alphaMode; - vk::Extent2D imageExtent; - }; - static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplaySurfaceCreateInfoKHR : public layout::DisplaySurfaceCreateInfoKHR + struct DisplaySurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(), vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(), @@ -32861,16 +30900,30 @@ namespace VULKAN_HPP_NAMESPACE float globalAlpha_ = 0, vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque, vk::Extent2D imageExtent_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT - : layout::DisplaySurfaceCreateInfoKHR( flags_, displayMode_, planeIndex_, planeStackIndex_, transform_, globalAlpha_, alphaMode_, imageExtent_ ) + : flags( flags_ ) + , displayMode( displayMode_ ) + , planeIndex( planeIndex_ ) + , planeStackIndex( planeStackIndex_ ) + , transform( transform_ ) + , globalAlpha( globalAlpha_ ) + , alphaMode( alphaMode_ ) + , imageExtent( imageExtent_ ) {} + vk::DisplaySurfaceCreateInfoKHR & operator=( vk::DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplaySurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplaySurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplaySurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32957,8 +31010,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplaySurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::DisplaySurfaceCreateFlagsKHR flags; + vk::DisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + vk::SurfaceTransformFlagBitsKHR transform; + float globalAlpha; + vk::DisplayPlaneAlphaFlagBitsKHR alphaMode; + vk::Extent2D imageExtent; }; static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -32979,12 +31041,12 @@ namespace VULKAN_HPP_NAMESPACE DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -33066,12 +31128,12 @@ namespace VULKAN_HPP_NAMESPACE DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -33141,12 +31203,12 @@ namespace VULKAN_HPP_NAMESPACE DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -33192,17 +31254,22 @@ namespace VULKAN_HPP_NAMESPACE struct DrmFormatModifierPropertiesEXT { - DrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT + DrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = 0, + uint32_t drmFormatModifierPlaneCount_ = 0, + vk::FormatFeatureFlags drmFormatModifierTilingFeatures_ = vk::FormatFeatureFlags() ) VULKAN_HPP_NOEXCEPT + : drmFormatModifier( drmFormatModifier_ ) + , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ) + , drmFormatModifierTilingFeatures( drmFormatModifierTilingFeatures_ ) {} DrmFormatModifierPropertiesEXT( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DrmFormatModifierPropertiesEXT& operator=( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -33236,47 +31303,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DrmFormatModifierPropertiesListEXT { - struct DrmFormatModifierPropertiesListEXT - { - protected: - DrmFormatModifierPropertiesListEXT() VULKAN_HPP_NOEXCEPT - {} - - DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT; - void* pNext = nullptr; - uint32_t drmFormatModifierCount; - vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; - }; - static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "layout struct and wrapper have different size!" ); - } - - struct DrmFormatModifierPropertiesListEXT : public layout::DrmFormatModifierPropertiesListEXT - { - DrmFormatModifierPropertiesListEXT() VULKAN_HPP_NOEXCEPT - : layout::DrmFormatModifierPropertiesListEXT() + DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = 0, + vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = nullptr ) VULKAN_HPP_NOEXCEPT + : drmFormatModifierCount( drmFormatModifierCount_ ) + , pDrmFormatModifierProperties( pDrmFormatModifierProperties_ ) {} + vk::DrmFormatModifierPropertiesListEXT & operator=( vk::DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DrmFormatModifierPropertiesListEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DrmFormatModifierPropertiesListEXT( rhs ) - {} + { + *this = rhs; + } DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DrmFormatModifierPropertiesListEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33303,53 +31351,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DrmFormatModifierPropertiesListEXT::sType; + public: + const vk::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT; + void* pNext = nullptr; + uint32_t drmFormatModifierCount; + vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; }; static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct EventCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - {} - - EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eEventCreateInfo; - const void* pNext = nullptr; - vk::EventCreateFlags flags; - }; - static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct EventCreateInfo : public layout::EventCreateInfo + struct EventCreateInfo { VULKAN_HPP_CONSTEXPR EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() ) VULKAN_HPP_NOEXCEPT - : layout::EventCreateInfo( flags_ ) + : flags( flags_ ) {} + vk::EventCreateInfo & operator=( vk::EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::EventCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::EventCreateInfo( rhs ) - {} + { + *this = rhs; + } EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::EventCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33387,53 +31417,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::EventCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eEventCreateInfo; + const void* pNext = nullptr; + vk::EventCreateFlags flags; }; static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExportFenceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportFenceCreateInfo; - const void* pNext = nullptr; - vk::ExternalFenceHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExportFenceCreateInfo : public layout::ExportFenceCreateInfo + struct ExportFenceCreateInfo { VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExportFenceCreateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExportFenceCreateInfo & operator=( vk::ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportFenceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportFenceCreateInfo( rhs ) - {} + { + *this = rhs; + } ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportFenceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33471,63 +31482,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportFenceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExportFenceCreateInfo; + const void* pNext = nullptr; + vk::ExternalFenceHandleTypeFlags handleTypes; }; static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ExportFenceWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - {} - - ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ExportFenceWin32HandleInfoKHR : public layout::ExportFenceWin32HandleInfoKHR + struct ExportFenceWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ExportFenceWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) {} + vk::ExportFenceWin32HandleInfoKHR & operator=( vk::ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportFenceWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportFenceWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportFenceWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33579,54 +31567,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportFenceWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; }; static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct ExportMemoryAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportMemoryAllocateInfo; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExportMemoryAllocateInfo : public layout::ExportMemoryAllocateInfo + struct ExportMemoryAllocateInfo { VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryAllocateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExportMemoryAllocateInfo & operator=( vk::ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryAllocateInfo( rhs ) - {} + { + *this = rhs; + } ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportMemoryAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33664,53 +31635,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportMemoryAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExportMemoryAllocateInfo; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlags handleTypes; }; static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExportMemoryAllocateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportMemoryAllocateInfoNV; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct ExportMemoryAllocateInfoNV : public layout::ExportMemoryAllocateInfoNV + struct ExportMemoryAllocateInfoNV { VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryAllocateInfoNV( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExportMemoryAllocateInfoNV & operator=( vk::ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryAllocateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryAllocateInfoNV( rhs ) - {} + { + *this = rhs; + } ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportMemoryAllocateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33748,63 +31700,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportMemoryAllocateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eExportMemoryAllocateInfoNV; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagsNV handleTypes; }; static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ExportMemoryWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - {} - - ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ExportMemoryWin32HandleInfoKHR : public layout::ExportMemoryWin32HandleInfoKHR + struct ExportMemoryWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) {} + vk::ExportMemoryWin32HandleInfoKHR & operator=( vk::ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportMemoryWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33856,8 +31785,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportMemoryWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; }; static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -33865,51 +31798,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ExportMemoryWin32HandleInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0 ) VULKAN_HPP_NOEXCEPT - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - {} - - ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - }; - static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct ExportMemoryWin32HandleInfoNV : public layout::ExportMemoryWin32HandleInfoNV + struct ExportMemoryWin32HandleInfoNV { VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryWin32HandleInfoNV( pAttributes_, dwAccess_ ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) {} + vk::ExportMemoryWin32HandleInfoNV & operator=( vk::ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryWin32HandleInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryWin32HandleInfoNV( rhs ) - {} + { + *this = rhs; + } ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportMemoryWin32HandleInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33954,54 +31864,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportMemoryWin32HandleInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; }; static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct ExportSemaphoreCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportSemaphoreCreateInfo; - const void* pNext = nullptr; - vk::ExternalSemaphoreHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExportSemaphoreCreateInfo : public layout::ExportSemaphoreCreateInfo + struct ExportSemaphoreCreateInfo { VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExportSemaphoreCreateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExportSemaphoreCreateInfo & operator=( vk::ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportSemaphoreCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportSemaphoreCreateInfo( rhs ) - {} + { + *this = rhs; + } ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportSemaphoreCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34039,63 +31931,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportSemaphoreCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExportSemaphoreCreateInfo; + const void* pNext = nullptr; + vk::ExternalSemaphoreHandleTypeFlags handleTypes; }; static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ExportSemaphoreWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - {} - - ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ExportSemaphoreWin32HandleInfoKHR : public layout::ExportSemaphoreWin32HandleInfoKHR + struct ExportSemaphoreWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ExportSemaphoreWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) {} + vk::ExportSemaphoreWin32HandleInfoKHR & operator=( vk::ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportSemaphoreWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportSemaphoreWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportSemaphoreWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34147,8 +32016,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportSemaphoreWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; }; static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -34156,17 +32029,22 @@ namespace VULKAN_HPP_NAMESPACE struct ExtensionProperties { - ExtensionProperties() VULKAN_HPP_NOEXCEPT - {} + ExtensionProperties( std::array const& extensionName_ = { { 0 } }, + uint32_t specVersion_ = 0 ) VULKAN_HPP_NOEXCEPT + : extensionName{} + , specVersion( specVersion_ ) + { + vk::ConstExpressionArrayCopy::copy( extensionName, extensionName_ ); + } ExtensionProperties( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ExtensionProperties& operator=( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -34200,17 +32078,22 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalMemoryProperties { - ExternalMemoryProperties() VULKAN_HPP_NOEXCEPT + ExternalMemoryProperties( vk::ExternalMemoryFeatureFlags externalMemoryFeatures_ = vk::ExternalMemoryFeatureFlags(), + vk::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalMemoryHandleTypeFlags(), + vk::ExternalMemoryHandleTypeFlags compatibleHandleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT + : externalMemoryFeatures( externalMemoryFeatures_ ) + , exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ) + , compatibleHandleTypes( compatibleHandleTypes_ ) {} ExternalMemoryProperties( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ExternalMemoryProperties& operator=( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -34244,46 +32127,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ExternalBufferProperties { - struct ExternalBufferProperties - { - protected: - ExternalBufferProperties() VULKAN_HPP_NOEXCEPT - {} - - ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalBufferProperties; - void* pNext = nullptr; - vk::ExternalMemoryProperties externalMemoryProperties; - }; - static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "layout struct and wrapper have different size!" ); - } - - struct ExternalBufferProperties : public layout::ExternalBufferProperties - { - ExternalBufferProperties() VULKAN_HPP_NOEXCEPT - : layout::ExternalBufferProperties() + ExternalBufferProperties( vk::ExternalMemoryProperties externalMemoryProperties_ = vk::ExternalMemoryProperties() ) VULKAN_HPP_NOEXCEPT + : externalMemoryProperties( externalMemoryProperties_ ) {} + vk::ExternalBufferProperties & operator=( vk::ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalBufferProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalBufferProperties( rhs ) - {} + { + *this = rhs; + } ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalBufferProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34309,54 +32172,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalBufferProperties::sType; + public: + const vk::StructureType sType = StructureType::eExternalBufferProperties; + void* pNext = nullptr; + vk::ExternalMemoryProperties externalMemoryProperties; }; static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ExternalFenceProperties { - struct ExternalFenceProperties - { - protected: - ExternalFenceProperties() VULKAN_HPP_NOEXCEPT - {} - - ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalFenceProperties; - void* pNext = nullptr; - vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes; - vk::ExternalFenceHandleTypeFlags compatibleHandleTypes; - vk::ExternalFenceFeatureFlags externalFenceFeatures; - }; - static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "layout struct and wrapper have different size!" ); - } - - struct ExternalFenceProperties : public layout::ExternalFenceProperties - { - ExternalFenceProperties() VULKAN_HPP_NOEXCEPT - : layout::ExternalFenceProperties() + ExternalFenceProperties( vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalFenceHandleTypeFlags(), + vk::ExternalFenceHandleTypeFlags compatibleHandleTypes_ = vk::ExternalFenceHandleTypeFlags(), + vk::ExternalFenceFeatureFlags externalFenceFeatures_ = vk::ExternalFenceFeatureFlags() ) VULKAN_HPP_NOEXCEPT + : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ) + , compatibleHandleTypes( compatibleHandleTypes_ ) + , externalFenceFeatures( externalFenceFeatures_ ) {} + vk::ExternalFenceProperties & operator=( vk::ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalFenceProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalFenceProperties( rhs ) - {} + { + *this = rhs; + } ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalFenceProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34384,55 +32231,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalFenceProperties::sType; + public: + const vk::StructureType sType = StructureType::eExternalFenceProperties; + void* pNext = nullptr; + vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + vk::ExternalFenceHandleTypeFlags compatibleHandleTypes; + vk::ExternalFenceFeatureFlags externalFenceFeatures; }; static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout - { - struct ExternalFormatANDROID - { - protected: - VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = 0 ) VULKAN_HPP_NOEXCEPT - : externalFormat( externalFormat_ ) - {} - - ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalFormatANDROID; - void* pNext = nullptr; - uint64_t externalFormat; - }; - static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "layout struct and wrapper have different size!" ); - } - - struct ExternalFormatANDROID : public layout::ExternalFormatANDROID + struct ExternalFormatANDROID { VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ExternalFormatANDROID( externalFormat_ ) + : externalFormat( externalFormat_ ) {} + vk::ExternalFormatANDROID & operator=( vk::ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalFormatANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalFormatANDROID( rhs ) - {} + { + *this = rhs; + } ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalFormatANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34470,53 +32300,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalFormatANDROID::sType; + public: + const vk::StructureType sType = StructureType::eExternalFormatANDROID; + void* pNext = nullptr; + uint64_t externalFormat; }; static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - namespace layout + struct ExternalImageFormatProperties { - struct ExternalImageFormatProperties - { - protected: - ExternalImageFormatProperties() VULKAN_HPP_NOEXCEPT - {} - - ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalImageFormatProperties; - void* pNext = nullptr; - vk::ExternalMemoryProperties externalMemoryProperties; - }; - static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "layout struct and wrapper have different size!" ); - } - - struct ExternalImageFormatProperties : public layout::ExternalImageFormatProperties - { - ExternalImageFormatProperties() VULKAN_HPP_NOEXCEPT - : layout::ExternalImageFormatProperties() + ExternalImageFormatProperties( vk::ExternalMemoryProperties externalMemoryProperties_ = vk::ExternalMemoryProperties() ) VULKAN_HPP_NOEXCEPT + : externalMemoryProperties( externalMemoryProperties_ ) {} + vk::ExternalImageFormatProperties & operator=( vk::ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalImageFormatProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalImageFormatProperties( rhs ) - {} + { + *this = rhs; + } ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalImageFormatProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34542,25 +32354,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalImageFormatProperties::sType; + public: + const vk::StructureType sType = StructureType::eExternalImageFormatProperties; + void* pNext = nullptr; + vk::ExternalMemoryProperties externalMemoryProperties; }; static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct ImageFormatProperties { - ImageFormatProperties() VULKAN_HPP_NOEXCEPT + ImageFormatProperties( vk::Extent3D maxExtent_ = vk::Extent3D(), + uint32_t maxMipLevels_ = 0, + uint32_t maxArrayLayers_ = 0, + vk::SampleCountFlags sampleCounts_ = vk::SampleCountFlags(), + vk::DeviceSize maxResourceSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxExtent( maxExtent_ ) + , maxMipLevels( maxMipLevels_ ) + , maxArrayLayers( maxArrayLayers_ ) + , sampleCounts( sampleCounts_ ) + , maxResourceSize( maxResourceSize_ ) {} ImageFormatProperties( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageFormatProperties& operator=( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -34600,17 +32423,24 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalImageFormatPropertiesNV { - ExternalImageFormatPropertiesNV() VULKAN_HPP_NOEXCEPT + ExternalImageFormatPropertiesNV( vk::ImageFormatProperties imageFormatProperties_ = vk::ImageFormatProperties(), + vk::ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = vk::ExternalMemoryFeatureFlagsNV(), + vk::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV(), + vk::ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT + : imageFormatProperties( imageFormatProperties_ ) + , externalMemoryFeatures( externalMemoryFeatures_ ) + , exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ) + , compatibleHandleTypes( compatibleHandleTypes_ ) {} ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -34646,47 +32476,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExternalMemoryBufferCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExternalMemoryBufferCreateInfo : public layout::ExternalMemoryBufferCreateInfo + struct ExternalMemoryBufferCreateInfo { VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryBufferCreateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExternalMemoryBufferCreateInfo & operator=( vk::ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryBufferCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryBufferCreateInfo( rhs ) - {} + { + *this = rhs; + } ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalMemoryBufferCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34724,53 +32533,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalMemoryBufferCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlags handleTypes; }; static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExternalMemoryImageCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfo; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExternalMemoryImageCreateInfo : public layout::ExternalMemoryImageCreateInfo + struct ExternalMemoryImageCreateInfo { VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryImageCreateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExternalMemoryImageCreateInfo & operator=( vk::ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryImageCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryImageCreateInfo( rhs ) - {} + { + *this = rhs; + } ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalMemoryImageCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34808,53 +32598,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalMemoryImageCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfo; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlags handleTypes; }; static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExternalMemoryImageCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct ExternalMemoryImageCreateInfoNV : public layout::ExternalMemoryImageCreateInfoNV + struct ExternalMemoryImageCreateInfoNV { VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryImageCreateInfoNV( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExternalMemoryImageCreateInfoNV & operator=( vk::ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryImageCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryImageCreateInfoNV( rhs ) - {} + { + *this = rhs; + } ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalMemoryImageCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34892,54 +32663,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalMemoryImageCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagsNV handleTypes; }; static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ExternalSemaphoreProperties { - struct ExternalSemaphoreProperties - { - protected: - ExternalSemaphoreProperties() VULKAN_HPP_NOEXCEPT - {} - - ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalSemaphoreProperties; - void* pNext = nullptr; - vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; - vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes; - vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures; - }; - static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "layout struct and wrapper have different size!" ); - } - - struct ExternalSemaphoreProperties : public layout::ExternalSemaphoreProperties - { - ExternalSemaphoreProperties() VULKAN_HPP_NOEXCEPT - : layout::ExternalSemaphoreProperties() + ExternalSemaphoreProperties( vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalSemaphoreHandleTypeFlags(), + vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = vk::ExternalSemaphoreHandleTypeFlags(), + vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures_ = vk::ExternalSemaphoreFeatureFlags() ) VULKAN_HPP_NOEXCEPT + : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ) + , compatibleHandleTypes( compatibleHandleTypes_ ) + , externalSemaphoreFeatures( externalSemaphoreFeatures_ ) {} + vk::ExternalSemaphoreProperties & operator=( vk::ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalSemaphoreProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalSemaphoreProperties( rhs ) - {} + { + *this = rhs; + } ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalSemaphoreProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34967,53 +32722,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalSemaphoreProperties::sType; + public: + const vk::StructureType sType = StructureType::eExternalSemaphoreProperties; + void* pNext = nullptr; + vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures; }; static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FenceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - {} - - FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFenceCreateInfo; - const void* pNext = nullptr; - vk::FenceCreateFlags flags; - }; - static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct FenceCreateInfo : public layout::FenceCreateInfo + struct FenceCreateInfo { VULKAN_HPP_CONSTEXPR FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() ) VULKAN_HPP_NOEXCEPT - : layout::FenceCreateInfo( flags_ ) + : flags( flags_ ) {} + vk::FenceCreateInfo & operator=( vk::FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FenceCreateInfo( rhs ) - {} + { + *this = rhs; + } FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FenceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35051,57 +32789,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FenceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eFenceCreateInfo; + const void* pNext = nullptr; + vk::FenceCreateFlags flags; }; static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FenceGetFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(), - vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : fence( fence_ ) - , handleType( handleType_ ) - {} - - FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFenceGetFdInfoKHR; - const void* pNext = nullptr; - vk::Fence fence; - vk::ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct FenceGetFdInfoKHR : public layout::FenceGetFdInfoKHR + struct FenceGetFdInfoKHR { VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(), vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::FenceGetFdInfoKHR( fence_, handleType_ ) + : fence( fence_ ) + , handleType( handleType_ ) {} + vk::FenceGetFdInfoKHR & operator=( vk::FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceGetFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FenceGetFdInfoKHR( rhs ) - {} + { + *this = rhs; + } FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FenceGetFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35146,59 +32863,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FenceGetFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eFenceGetFdInfoKHR; + const void* pNext = nullptr; + vk::Fence fence; + vk::ExternalFenceHandleTypeFlagBits handleType; }; static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct FenceGetWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(), - vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : fence( fence_ ) - , handleType( handleType_ ) - {} - - FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::Fence fence; - vk::ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct FenceGetWin32HandleInfoKHR : public layout::FenceGetWin32HandleInfoKHR + struct FenceGetWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(), vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::FenceGetWin32HandleInfoKHR( fence_, handleType_ ) + : fence( fence_ ) + , handleType( handleType_ ) {} + vk::FenceGetWin32HandleInfoKHR & operator=( vk::FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FenceGetWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FenceGetWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35243,54 +32940,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FenceGetWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::Fence fence; + vk::ExternalFenceHandleTypeFlagBits handleType; }; static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout + struct FilterCubicImageViewImageFormatPropertiesEXT { - struct FilterCubicImageViewImageFormatPropertiesEXT - { - protected: - FilterCubicImageViewImageFormatPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; - void* pNext = nullptr; - vk::Bool32 filterCubic; - vk::Bool32 filterCubicMinmax; - }; - static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct FilterCubicImageViewImageFormatPropertiesEXT : public layout::FilterCubicImageViewImageFormatPropertiesEXT - { - FilterCubicImageViewImageFormatPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::FilterCubicImageViewImageFormatPropertiesEXT() + FilterCubicImageViewImageFormatPropertiesEXT( vk::Bool32 filterCubic_ = 0, + vk::Bool32 filterCubicMinmax_ = 0 ) VULKAN_HPP_NOEXCEPT + : filterCubic( filterCubic_ ) + , filterCubicMinmax( filterCubicMinmax_ ) {} + vk::FilterCubicImageViewImageFormatPropertiesEXT & operator=( vk::FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FilterCubicImageViewImageFormatPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FilterCubicImageViewImageFormatPropertiesEXT( rhs ) - {} + { + *this = rhs; + } FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FilterCubicImageViewImageFormatPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35317,25 +32998,33 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FilterCubicImageViewImageFormatPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; + void* pNext = nullptr; + vk::Bool32 filterCubic; + vk::Bool32 filterCubicMinmax; }; static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct FormatProperties { - FormatProperties() VULKAN_HPP_NOEXCEPT + FormatProperties( vk::FormatFeatureFlags linearTilingFeatures_ = vk::FormatFeatureFlags(), + vk::FormatFeatureFlags optimalTilingFeatures_ = vk::FormatFeatureFlags(), + vk::FormatFeatureFlags bufferFeatures_ = vk::FormatFeatureFlags() ) VULKAN_HPP_NOEXCEPT + : linearTilingFeatures( linearTilingFeatures_ ) + , optimalTilingFeatures( optimalTilingFeatures_ ) + , bufferFeatures( bufferFeatures_ ) {} FormatProperties( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } FormatProperties& operator=( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -35369,46 +33058,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct FormatProperties2 { - struct FormatProperties2 - { - protected: - FormatProperties2() VULKAN_HPP_NOEXCEPT - {} - - FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FormatProperties2& operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFormatProperties2; - void* pNext = nullptr; - vk::FormatProperties formatProperties; - }; - static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct FormatProperties2 : public layout::FormatProperties2 - { - FormatProperties2() VULKAN_HPP_NOEXCEPT - : layout::FormatProperties2() + FormatProperties2( vk::FormatProperties formatProperties_ = vk::FormatProperties() ) VULKAN_HPP_NOEXCEPT + : formatProperties( formatProperties_ ) {} + vk::FormatProperties2 & operator=( vk::FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FormatProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FormatProperties2( rhs ) - {} + { + *this = rhs; + } FormatProperties2& operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FormatProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35434,59 +33103,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FormatProperties2::sType; + public: + const vk::StructureType sType = StructureType::eFormatProperties2; + void* pNext = nullptr; + vk::FormatProperties formatProperties; }; static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FramebufferAttachmentImageInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(), - vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), - uint32_t width_ = 0, - uint32_t height_ = 0, - uint32_t layerCount_ = 0, - uint32_t viewFormatCount_ = 0, - const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , usage( usage_ ) - , width( width_ ) - , height( height_ ) - , layerCount( layerCount_ ) - , viewFormatCount( viewFormatCount_ ) - , pViewFormats( pViewFormats_ ) - {} - - FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFramebufferAttachmentImageInfoKHR; - const void* pNext = nullptr; - vk::ImageCreateFlags flags; - vk::ImageUsageFlags usage; - uint32_t width; - uint32_t height; - uint32_t layerCount; - uint32_t viewFormatCount; - const vk::Format* pViewFormats; - }; - static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct FramebufferAttachmentImageInfoKHR : public layout::FramebufferAttachmentImageInfoKHR + struct FramebufferAttachmentImageInfoKHR { VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(), vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), @@ -35495,16 +33120,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t layerCount_ = 0, uint32_t viewFormatCount_ = 0, const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferAttachmentImageInfoKHR( flags_, usage_, width_, height_, layerCount_, viewFormatCount_, pViewFormats_ ) + : flags( flags_ ) + , usage( usage_ ) + , width( width_ ) + , height( height_ ) + , layerCount( layerCount_ ) + , viewFormatCount( viewFormatCount_ ) + , pViewFormats( pViewFormats_ ) {} + vk::FramebufferAttachmentImageInfoKHR & operator=( vk::FramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferAttachmentImageInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferAttachmentImageInfoKHR( rhs ) - {} + { + *this = rhs; + } FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FramebufferAttachmentImageInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35584,57 +33222,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FramebufferAttachmentImageInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eFramebufferAttachmentImageInfoKHR; + const void* pNext = nullptr; + vk::ImageCreateFlags flags; + vk::ImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + const vk::Format* pViewFormats; }; static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FramebufferAttachmentsCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0, - const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr ) VULKAN_HPP_NOEXCEPT - : attachmentImageInfoCount( attachmentImageInfoCount_ ) - , pAttachmentImageInfos( pAttachmentImageInfos_ ) - {} - - FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR; - const void* pNext = nullptr; - uint32_t attachmentImageInfoCount; - const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos; - }; - static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct FramebufferAttachmentsCreateInfoKHR : public layout::FramebufferAttachmentsCreateInfoKHR + struct FramebufferAttachmentsCreateInfoKHR { VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0, const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferAttachmentsCreateInfoKHR( attachmentImageInfoCount_, pAttachmentImageInfos_ ) + : attachmentImageInfoCount( attachmentImageInfoCount_ ) + , pAttachmentImageInfos( pAttachmentImageInfos_ ) {} + vk::FramebufferAttachmentsCreateInfoKHR & operator=( vk::FramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferAttachmentsCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferAttachmentsCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FramebufferAttachmentsCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35679,59 +33302,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FramebufferAttachmentsCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR; + const void* pNext = nullptr; + uint32_t attachmentImageInfoCount; + const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos; }; static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FramebufferCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(), - vk::RenderPass renderPass_ = vk::RenderPass(), - uint32_t attachmentCount_ = 0, - const vk::ImageView* pAttachments_ = nullptr, - uint32_t width_ = 0, - uint32_t height_ = 0, - uint32_t layers_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , renderPass( renderPass_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , width( width_ ) - , height( height_ ) - , layers( layers_ ) - {} - - FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFramebufferCreateInfo; - const void* pNext = nullptr; - vk::FramebufferCreateFlags flags; - vk::RenderPass renderPass; - uint32_t attachmentCount; - const vk::ImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; - }; - static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct FramebufferCreateInfo : public layout::FramebufferCreateInfo + struct FramebufferCreateInfo { VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(), vk::RenderPass renderPass_ = vk::RenderPass(), @@ -35740,16 +33320,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t width_ = 0, uint32_t height_ = 0, uint32_t layers_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferCreateInfo( flags_, renderPass_, attachmentCount_, pAttachments_, width_, height_, layers_ ) + : flags( flags_ ) + , renderPass( renderPass_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , width( width_ ) + , height( height_ ) + , layers( layers_ ) {} + vk::FramebufferCreateInfo & operator=( vk::FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferCreateInfo( rhs ) - {} + { + *this = rhs; + } FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FramebufferCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35829,55 +33422,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FramebufferCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eFramebufferCreateInfo; + const void* pNext = nullptr; + vk::FramebufferCreateFlags flags; + vk::RenderPass renderPass; + uint32_t attachmentCount; + const vk::ImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; }; static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct FramebufferMixedSamplesCombinationNV { - struct FramebufferMixedSamplesCombinationNV - { - protected: - FramebufferMixedSamplesCombinationNV() VULKAN_HPP_NOEXCEPT - {} - - FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV; - void* pNext = nullptr; - vk::CoverageReductionModeNV coverageReductionMode; - vk::SampleCountFlagBits rasterizationSamples; - vk::SampleCountFlags depthStencilSamples; - vk::SampleCountFlags colorSamples; - }; - static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "layout struct and wrapper have different size!" ); - } - - struct FramebufferMixedSamplesCombinationNV : public layout::FramebufferMixedSamplesCombinationNV - { - FramebufferMixedSamplesCombinationNV() VULKAN_HPP_NOEXCEPT - : layout::FramebufferMixedSamplesCombinationNV() + FramebufferMixedSamplesCombinationNV( vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge, + vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1, + vk::SampleCountFlags depthStencilSamples_ = vk::SampleCountFlags(), + vk::SampleCountFlags colorSamples_ = vk::SampleCountFlags() ) VULKAN_HPP_NOEXCEPT + : coverageReductionMode( coverageReductionMode_ ) + , rasterizationSamples( rasterizationSamples_ ) + , depthStencilSamples( depthStencilSamples_ ) + , colorSamples( colorSamples_ ) {} + vk::FramebufferMixedSamplesCombinationNV & operator=( vk::FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferMixedSamplesCombinationNV ) - sizeof( vk::StructureType ) ); + return *this; + } + FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferMixedSamplesCombinationNV( rhs ) - {} + { + *this = rhs; + } FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FramebufferMixedSamplesCombinationNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35906,8 +33490,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FramebufferMixedSamplesCombinationNV::sType; + public: + const vk::StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV; + void* pNext = nullptr; + vk::CoverageReductionModeNV coverageReductionMode; + vk::SampleCountFlagBits rasterizationSamples; + vk::SampleCountFlags depthStencilSamples; + vk::SampleCountFlags colorSamples; }; static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -35924,12 +33513,12 @@ namespace VULKAN_HPP_NAMESPACE VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -35995,12 +33584,12 @@ namespace VULKAN_HPP_NAMESPACE VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -36060,63 +33649,34 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineVertexInputStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(), - uint32_t vertexBindingDescriptionCount_ = 0, - const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, - uint32_t vertexAttributeDescriptionCount_ = 0, - const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ) - , pVertexBindingDescriptions( pVertexBindingDescriptions_ ) - , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ) - , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ ) - {} - - PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const vk::VertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions; - }; - static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineVertexInputStateCreateInfo : public layout::PipelineVertexInputStateCreateInfo + struct PipelineVertexInputStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_ = 0, const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, uint32_t vertexAttributeDescriptionCount_ = 0, const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineVertexInputStateCreateInfo( flags_, vertexBindingDescriptionCount_, pVertexBindingDescriptions_, vertexAttributeDescriptionCount_, pVertexAttributeDescriptions_ ) + : flags( flags_ ) + , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ) + , pVertexBindingDescriptions( pVertexBindingDescriptions_ ) + , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ) + , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ ) {} + vk::PipelineVertexInputStateCreateInfo & operator=( vk::PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineVertexInputStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineVertexInputStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineVertexInputStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36182,61 +33742,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineVertexInputStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const vk::VertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions; }; static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineInputAssemblyStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(), - vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList, - vk::Bool32 primitiveRestartEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , topology( topology_ ) - , primitiveRestartEnable( primitiveRestartEnable_ ) - {} - - PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineInputAssemblyStateCreateFlags flags; - vk::PrimitiveTopology topology; - vk::Bool32 primitiveRestartEnable; - }; - static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineInputAssemblyStateCreateInfo : public layout::PipelineInputAssemblyStateCreateInfo + struct PipelineInputAssemblyStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(), vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList, vk::Bool32 primitiveRestartEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineInputAssemblyStateCreateInfo( flags_, topology_, primitiveRestartEnable_ ) + : flags( flags_ ) + , topology( topology_ ) + , primitiveRestartEnable( primitiveRestartEnable_ ) {} + vk::PipelineInputAssemblyStateCreateInfo & operator=( vk::PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineInputAssemblyStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineInputAssemblyStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineInputAssemblyStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36288,57 +33829,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineInputAssemblyStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineInputAssemblyStateCreateFlags flags; + vk::PrimitiveTopology topology; + vk::Bool32 primitiveRestartEnable; }; static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineTessellationStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(), - uint32_t patchControlPoints_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , patchControlPoints( patchControlPoints_ ) - {} - - PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; - }; - static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineTessellationStateCreateInfo : public layout::PipelineTessellationStateCreateInfo + struct PipelineTessellationStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineTessellationStateCreateInfo( flags_, patchControlPoints_ ) + : flags( flags_ ) + , patchControlPoints( patchControlPoints_ ) {} + vk::PipelineTessellationStateCreateInfo & operator=( vk::PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineTessellationStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineTessellationStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineTessellationStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36383,8 +33905,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineTessellationStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; }; static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -36407,12 +33932,12 @@ namespace VULKAN_HPP_NAMESPACE Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Viewport& operator=( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -36488,63 +34013,34 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(), - uint32_t viewportCount_ = 0, - const vk::Viewport* pViewports_ = nullptr, - uint32_t scissorCount_ = 0, - const vk::Rect2D* pScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , viewportCount( viewportCount_ ) - , pViewports( pViewports_ ) - , scissorCount( scissorCount_ ) - , pScissors( pScissors_ ) - {} - - PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const vk::Viewport* pViewports; - uint32_t scissorCount; - const vk::Rect2D* pScissors; - }; - static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportStateCreateInfo : public layout::PipelineViewportStateCreateInfo + struct PipelineViewportStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(), uint32_t viewportCount_ = 0, const vk::Viewport* pViewports_ = nullptr, uint32_t scissorCount_ = 0, const vk::Rect2D* pScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportStateCreateInfo( flags_, viewportCount_, pViewports_, scissorCount_, pScissors_ ) + : flags( flags_ ) + , viewportCount( viewportCount_ ) + , pViewports( pViewports_ ) + , scissorCount( scissorCount_ ) + , pScissors( pScissors_ ) {} + vk::PipelineViewportStateCreateInfo & operator=( vk::PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36610,71 +34106,19 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const vk::Viewport* pViewports; + uint32_t scissorCount; + const vk::Rect2D* pScissors; }; static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(), - vk::Bool32 depthClampEnable_ = 0, - vk::Bool32 rasterizerDiscardEnable_ = 0, - vk::PolygonMode polygonMode_ = vk::PolygonMode::eFill, - vk::CullModeFlags cullMode_ = vk::CullModeFlags(), - vk::FrontFace frontFace_ = vk::FrontFace::eCounterClockwise, - vk::Bool32 depthBiasEnable_ = 0, - float depthBiasConstantFactor_ = 0, - float depthBiasClamp_ = 0, - float depthBiasSlopeFactor_ = 0, - float lineWidth_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , depthClampEnable( depthClampEnable_ ) - , rasterizerDiscardEnable( rasterizerDiscardEnable_ ) - , polygonMode( polygonMode_ ) - , cullMode( cullMode_ ) - , frontFace( frontFace_ ) - , depthBiasEnable( depthBiasEnable_ ) - , depthBiasConstantFactor( depthBiasConstantFactor_ ) - , depthBiasClamp( depthBiasClamp_ ) - , depthBiasSlopeFactor( depthBiasSlopeFactor_ ) - , lineWidth( lineWidth_ ) - {} - - PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineRasterizationStateCreateFlags flags; - vk::Bool32 depthClampEnable; - vk::Bool32 rasterizerDiscardEnable; - vk::PolygonMode polygonMode; - vk::CullModeFlags cullMode; - vk::FrontFace frontFace; - vk::Bool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; - }; - static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationStateCreateInfo : public layout::PipelineRasterizationStateCreateInfo + struct PipelineRasterizationStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(), vk::Bool32 depthClampEnable_ = 0, @@ -36687,16 +34131,33 @@ namespace VULKAN_HPP_NAMESPACE float depthBiasClamp_ = 0, float depthBiasSlopeFactor_ = 0, float lineWidth_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateCreateInfo( flags_, depthClampEnable_, rasterizerDiscardEnable_, polygonMode_, cullMode_, frontFace_, depthBiasEnable_, depthBiasConstantFactor_, depthBiasClamp_, depthBiasSlopeFactor_, lineWidth_ ) + : flags( flags_ ) + , depthClampEnable( depthClampEnable_ ) + , rasterizerDiscardEnable( rasterizerDiscardEnable_ ) + , polygonMode( polygonMode_ ) + , cullMode( cullMode_ ) + , frontFace( frontFace_ ) + , depthBiasEnable( depthBiasEnable_ ) + , depthBiasConstantFactor( depthBiasConstantFactor_ ) + , depthBiasClamp( depthBiasClamp_ ) + , depthBiasSlopeFactor( depthBiasSlopeFactor_ ) + , lineWidth( lineWidth_ ) {} + vk::PipelineRasterizationStateCreateInfo & operator=( vk::PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36804,59 +34265,25 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineRasterizationStateCreateFlags flags; + vk::Bool32 depthClampEnable; + vk::Bool32 rasterizerDiscardEnable; + vk::PolygonMode polygonMode; + vk::CullModeFlags cullMode; + vk::FrontFace frontFace; + vk::Bool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; }; static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineMultisampleStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(), - vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1, - vk::Bool32 sampleShadingEnable_ = 0, - float minSampleShading_ = 0, - const vk::SampleMask* pSampleMask_ = nullptr, - vk::Bool32 alphaToCoverageEnable_ = 0, - vk::Bool32 alphaToOneEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , rasterizationSamples( rasterizationSamples_ ) - , sampleShadingEnable( sampleShadingEnable_ ) - , minSampleShading( minSampleShading_ ) - , pSampleMask( pSampleMask_ ) - , alphaToCoverageEnable( alphaToCoverageEnable_ ) - , alphaToOneEnable( alphaToOneEnable_ ) - {} - - PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineMultisampleStateCreateFlags flags; - vk::SampleCountFlagBits rasterizationSamples; - vk::Bool32 sampleShadingEnable; - float minSampleShading; - const vk::SampleMask* pSampleMask; - vk::Bool32 alphaToCoverageEnable; - vk::Bool32 alphaToOneEnable; - }; - static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineMultisampleStateCreateInfo : public layout::PipelineMultisampleStateCreateInfo + struct PipelineMultisampleStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(), vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1, @@ -36865,16 +34292,29 @@ namespace VULKAN_HPP_NAMESPACE const vk::SampleMask* pSampleMask_ = nullptr, vk::Bool32 alphaToCoverageEnable_ = 0, vk::Bool32 alphaToOneEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineMultisampleStateCreateInfo( flags_, rasterizationSamples_, sampleShadingEnable_, minSampleShading_, pSampleMask_, alphaToCoverageEnable_, alphaToOneEnable_ ) + : flags( flags_ ) + , rasterizationSamples( rasterizationSamples_ ) + , sampleShadingEnable( sampleShadingEnable_ ) + , minSampleShading( minSampleShading_ ) + , pSampleMask( pSampleMask_ ) + , alphaToCoverageEnable( alphaToCoverageEnable_ ) + , alphaToOneEnable( alphaToOneEnable_ ) {} + vk::PipelineMultisampleStateCreateInfo & operator=( vk::PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineMultisampleStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineMultisampleStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineMultisampleStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36954,8 +34394,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineMultisampleStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineMultisampleStateCreateFlags flags; + vk::SampleCountFlagBits rasterizationSamples; + vk::Bool32 sampleShadingEnable; + float minSampleShading; + const vk::SampleMask* pSampleMask; + vk::Bool32 alphaToCoverageEnable; + vk::Bool32 alphaToOneEnable; }; static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -36980,12 +34428,12 @@ namespace VULKAN_HPP_NAMESPACE StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } StencilOpState& operator=( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -37069,62 +34517,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineDepthStencilStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(), - vk::Bool32 depthTestEnable_ = 0, - vk::Bool32 depthWriteEnable_ = 0, - vk::CompareOp depthCompareOp_ = vk::CompareOp::eNever, - vk::Bool32 depthBoundsTestEnable_ = 0, - vk::Bool32 stencilTestEnable_ = 0, - vk::StencilOpState front_ = vk::StencilOpState(), - vk::StencilOpState back_ = vk::StencilOpState(), - float minDepthBounds_ = 0, - float maxDepthBounds_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , depthTestEnable( depthTestEnable_ ) - , depthWriteEnable( depthWriteEnable_ ) - , depthCompareOp( depthCompareOp_ ) - , depthBoundsTestEnable( depthBoundsTestEnable_ ) - , stencilTestEnable( stencilTestEnable_ ) - , front( front_ ) - , back( back_ ) - , minDepthBounds( minDepthBounds_ ) - , maxDepthBounds( maxDepthBounds_ ) - {} - - PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineDepthStencilStateCreateFlags flags; - vk::Bool32 depthTestEnable; - vk::Bool32 depthWriteEnable; - vk::CompareOp depthCompareOp; - vk::Bool32 depthBoundsTestEnable; - vk::Bool32 stencilTestEnable; - vk::StencilOpState front; - vk::StencilOpState back; - float minDepthBounds; - float maxDepthBounds; - }; - static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineDepthStencilStateCreateInfo : public layout::PipelineDepthStencilStateCreateInfo + struct PipelineDepthStencilStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(), vk::Bool32 depthTestEnable_ = 0, @@ -37136,16 +34529,32 @@ namespace VULKAN_HPP_NAMESPACE vk::StencilOpState back_ = vk::StencilOpState(), float minDepthBounds_ = 0, float maxDepthBounds_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDepthStencilStateCreateInfo( flags_, depthTestEnable_, depthWriteEnable_, depthCompareOp_, depthBoundsTestEnable_, stencilTestEnable_, front_, back_, minDepthBounds_, maxDepthBounds_ ) + : flags( flags_ ) + , depthTestEnable( depthTestEnable_ ) + , depthWriteEnable( depthWriteEnable_ ) + , depthCompareOp( depthCompareOp_ ) + , depthBoundsTestEnable( depthBoundsTestEnable_ ) + , stencilTestEnable( stencilTestEnable_ ) + , front( front_ ) + , back( back_ ) + , minDepthBounds( minDepthBounds_ ) + , maxDepthBounds( maxDepthBounds_ ) {} + vk::PipelineDepthStencilStateCreateInfo & operator=( vk::PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDepthStencilStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDepthStencilStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineDepthStencilStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -37246,8 +34655,19 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineDepthStencilStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineDepthStencilStateCreateFlags flags; + vk::Bool32 depthTestEnable; + vk::Bool32 depthWriteEnable; + vk::CompareOp depthCompareOp; + vk::Bool32 depthBoundsTestEnable; + vk::Bool32 stencilTestEnable; + vk::StencilOpState front; + vk::StencilOpState back; + float minDepthBounds; + float maxDepthBounds; }; static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -37274,12 +34694,12 @@ namespace VULKAN_HPP_NAMESPACE PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -37371,52 +34791,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineColorBlendStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(), - vk::Bool32 logicOpEnable_ = 0, - vk::LogicOp logicOp_ = vk::LogicOp::eClear, - uint32_t attachmentCount_ = 0, - const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr, - std::array const& blendConstants_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , logicOpEnable( logicOpEnable_ ) - , logicOp( logicOp_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , blendConstants{} - { - vk::ConstExpressionArrayCopy::copy( blendConstants, blendConstants_ ); - } - - PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineColorBlendStateCreateFlags flags; - vk::Bool32 logicOpEnable; - vk::LogicOp logicOp; - uint32_t attachmentCount; - const vk::PipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; - }; - static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineColorBlendStateCreateInfo : public layout::PipelineColorBlendStateCreateInfo + struct PipelineColorBlendStateCreateInfo { VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(), vk::Bool32 logicOpEnable_ = 0, @@ -37424,16 +34799,30 @@ namespace VULKAN_HPP_NAMESPACE uint32_t attachmentCount_ = 0, const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array const& blendConstants_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : layout::PipelineColorBlendStateCreateInfo( flags_, logicOpEnable_, logicOp_, attachmentCount_, pAttachments_, blendConstants_ ) - {} + : flags( flags_ ) + , logicOpEnable( logicOpEnable_ ) + , logicOp( logicOp_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , blendConstants{} + { + vk::ConstExpressionArrayCopy::copy( blendConstants, blendConstants_ ); + } + + vk::PipelineColorBlendStateCreateInfo & operator=( vk::PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineColorBlendStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineColorBlendStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineColorBlendStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -37506,61 +34895,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineColorBlendStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineColorBlendStateCreateFlags flags; + vk::Bool32 logicOpEnable; + vk::LogicOp logicOp; + uint32_t attachmentCount; + const vk::PipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; }; static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineDynamicStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(), - uint32_t dynamicStateCount_ = 0, - const vk::DynamicState* pDynamicStates_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , dynamicStateCount( dynamicStateCount_ ) - , pDynamicStates( pDynamicStates_ ) - {} - - PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const vk::DynamicState* pDynamicStates; - }; - static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineDynamicStateCreateInfo : public layout::PipelineDynamicStateCreateInfo + struct PipelineDynamicStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const vk::DynamicState* pDynamicStates_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDynamicStateCreateInfo( flags_, dynamicStateCount_, pDynamicStates_ ) + : flags( flags_ ) + , dynamicStateCount( dynamicStateCount_ ) + , pDynamicStates( pDynamicStates_ ) {} + vk::PipelineDynamicStateCreateInfo & operator=( vk::PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDynamicStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDynamicStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineDynamicStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -37612,89 +34983,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineDynamicStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const vk::DynamicState* pDynamicStates; }; static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct GraphicsPipelineCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), - uint32_t stageCount_ = 0, - const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr, - const vk::PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, - const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, - const vk::PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, - const vk::PipelineViewportStateCreateInfo* pViewportState_ = nullptr, - const vk::PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, - const vk::PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, - const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, - const vk::PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, - const vk::PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, - vk::PipelineLayout layout_ = vk::PipelineLayout(), - vk::RenderPass renderPass_ = vk::RenderPass(), - uint32_t subpass_ = 0, - vk::Pipeline basePipelineHandle_ = vk::Pipeline(), - int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , stageCount( stageCount_ ) - , pStages( pStages_ ) - , pVertexInputState( pVertexInputState_ ) - , pInputAssemblyState( pInputAssemblyState_ ) - , pTessellationState( pTessellationState_ ) - , pViewportState( pViewportState_ ) - , pRasterizationState( pRasterizationState_ ) - , pMultisampleState( pMultisampleState_ ) - , pDepthStencilState( pDepthStencilState_ ) - , pColorBlendState( pColorBlendState_ ) - , pDynamicState( pDynamicState_ ) - , layout( layout_ ) - , renderPass( renderPass_ ) - , subpass( subpass_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - {} - - GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eGraphicsPipelineCreateInfo; - const void* pNext = nullptr; - vk::PipelineCreateFlags flags; - uint32_t stageCount; - const vk::PipelineShaderStageCreateInfo* pStages; - const vk::PipelineVertexInputStateCreateInfo* pVertexInputState; - const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const vk::PipelineTessellationStateCreateInfo* pTessellationState; - const vk::PipelineViewportStateCreateInfo* pViewportState; - const vk::PipelineRasterizationStateCreateInfo* pRasterizationState; - const vk::PipelineMultisampleStateCreateInfo* pMultisampleState; - const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState; - const vk::PipelineColorBlendStateCreateInfo* pColorBlendState; - const vk::PipelineDynamicStateCreateInfo* pDynamicState; - vk::PipelineLayout layout; - vk::RenderPass renderPass; - uint32_t subpass; - vk::Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct GraphicsPipelineCreateInfo : public layout::GraphicsPipelineCreateInfo + struct GraphicsPipelineCreateInfo { VULKAN_HPP_CONSTEXPR GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), uint32_t stageCount_ = 0, @@ -37713,16 +35012,39 @@ namespace VULKAN_HPP_NAMESPACE uint32_t subpass_ = 0, vk::Pipeline basePipelineHandle_ = vk::Pipeline(), int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::GraphicsPipelineCreateInfo( flags_, stageCount_, pStages_, pVertexInputState_, pInputAssemblyState_, pTessellationState_, pViewportState_, pRasterizationState_, pMultisampleState_, pDepthStencilState_, pColorBlendState_, pDynamicState_, layout_, renderPass_, subpass_, basePipelineHandle_, basePipelineIndex_ ) + : flags( flags_ ) + , stageCount( stageCount_ ) + , pStages( pStages_ ) + , pVertexInputState( pVertexInputState_ ) + , pInputAssemblyState( pInputAssemblyState_ ) + , pTessellationState( pTessellationState_ ) + , pViewportState( pViewportState_ ) + , pRasterizationState( pRasterizationState_ ) + , pMultisampleState( pMultisampleState_ ) + , pDepthStencilState( pDepthStencilState_ ) + , pColorBlendState( pColorBlendState_ ) + , pDynamicState( pDynamicState_ ) + , layout( layout_ ) + , renderPass( renderPass_ ) + , subpass( subpass_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) {} + vk::GraphicsPipelineCreateInfo & operator=( vk::GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::GraphicsPipelineCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::GraphicsPipelineCreateInfo( rhs ) - {} + { + *this = rhs; + } GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::GraphicsPipelineCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -37872,8 +35194,26 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::GraphicsPipelineCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eGraphicsPipelineCreateInfo; + const void* pNext = nullptr; + vk::PipelineCreateFlags flags; + uint32_t stageCount; + const vk::PipelineShaderStageCreateInfo* pStages; + const vk::PipelineVertexInputStateCreateInfo* pVertexInputState; + const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const vk::PipelineTessellationStateCreateInfo* pTessellationState; + const vk::PipelineViewportStateCreateInfo* pViewportState; + const vk::PipelineRasterizationStateCreateInfo* pRasterizationState; + const vk::PipelineMultisampleStateCreateInfo* pMultisampleState; + const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState; + const vk::PipelineColorBlendStateCreateInfo* pColorBlendState; + const vk::PipelineDynamicStateCreateInfo* pDynamicState; + vk::PipelineLayout layout; + vk::RenderPass renderPass; + uint32_t subpass; + vk::Pipeline basePipelineHandle; + int32_t basePipelineIndex; }; static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -37888,12 +35228,12 @@ namespace VULKAN_HPP_NAMESPACE XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } XYColorEXT& operator=( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -37937,56 +35277,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct HdrMetadataEXT - { - protected: - VULKAN_HPP_CONSTEXPR HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(), - vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(), - vk::XYColorEXT displayPrimaryBlue_ = vk::XYColorEXT(), - vk::XYColorEXT whitePoint_ = vk::XYColorEXT(), - float maxLuminance_ = 0, - float minLuminance_ = 0, - float maxContentLightLevel_ = 0, - float maxFrameAverageLightLevel_ = 0 ) VULKAN_HPP_NOEXCEPT - : displayPrimaryRed( displayPrimaryRed_ ) - , displayPrimaryGreen( displayPrimaryGreen_ ) - , displayPrimaryBlue( displayPrimaryBlue_ ) - , whitePoint( whitePoint_ ) - , maxLuminance( maxLuminance_ ) - , minLuminance( minLuminance_ ) - , maxContentLightLevel( maxContentLightLevel_ ) - , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ ) - {} - - HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eHdrMetadataEXT; - const void* pNext = nullptr; - vk::XYColorEXT displayPrimaryRed; - vk::XYColorEXT displayPrimaryGreen; - vk::XYColorEXT displayPrimaryBlue; - vk::XYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; - }; - static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "layout struct and wrapper have different size!" ); - } - - struct HdrMetadataEXT : public layout::HdrMetadataEXT + struct HdrMetadataEXT { VULKAN_HPP_CONSTEXPR HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(), vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(), @@ -37996,16 +35287,30 @@ namespace VULKAN_HPP_NAMESPACE float minLuminance_ = 0, float maxContentLightLevel_ = 0, float maxFrameAverageLightLevel_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::HdrMetadataEXT( displayPrimaryRed_, displayPrimaryGreen_, displayPrimaryBlue_, whitePoint_, maxLuminance_, minLuminance_, maxContentLightLevel_, maxFrameAverageLightLevel_ ) + : displayPrimaryRed( displayPrimaryRed_ ) + , displayPrimaryGreen( displayPrimaryGreen_ ) + , displayPrimaryBlue( displayPrimaryBlue_ ) + , whitePoint( whitePoint_ ) + , maxLuminance( maxLuminance_ ) + , minLuminance( minLuminance_ ) + , maxContentLightLevel( maxContentLightLevel_ ) + , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ ) {} + vk::HdrMetadataEXT & operator=( vk::HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::HdrMetadataEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::HdrMetadataEXT( rhs ) - {} + { + *this = rhs; + } HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::HdrMetadataEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38092,53 +35397,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::HdrMetadataEXT::sType; + public: + const vk::StructureType sType = StructureType::eHdrMetadataEXT; + const void* pNext = nullptr; + vk::XYColorEXT displayPrimaryRed; + vk::XYColorEXT displayPrimaryGreen; + vk::XYColorEXT displayPrimaryBlue; + vk::XYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; }; static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct HeadlessSurfaceCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - {} - - HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT; - const void* pNext = nullptr; - vk::HeadlessSurfaceCreateFlagsEXT flags; - }; - static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct HeadlessSurfaceCreateInfoEXT : public layout::HeadlessSurfaceCreateInfoEXT + struct HeadlessSurfaceCreateInfoEXT { VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : layout::HeadlessSurfaceCreateInfoEXT( flags_ ) + : flags( flags_ ) {} + vk::HeadlessSurfaceCreateInfoEXT & operator=( vk::HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::HeadlessSurfaceCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::HeadlessSurfaceCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::HeadlessSurfaceCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38176,59 +35469,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::HeadlessSurfaceCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT; + const void* pNext = nullptr; + vk::HeadlessSurfaceCreateFlagsEXT flags; }; static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_IOS_MVK - namespace layout - { - struct IOSSurfaceCreateInfoMVK - { - protected: - VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(), - const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pView( pView_ ) - {} - - IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; - const void* pNext = nullptr; - vk::IOSSurfaceCreateFlagsMVK flags; - const void* pView; - }; - static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "layout struct and wrapper have different size!" ); - } - - struct IOSSurfaceCreateInfoMVK : public layout::IOSSurfaceCreateInfoMVK + struct IOSSurfaceCreateInfoMVK { VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::IOSSurfaceCreateInfoMVK( flags_, pView_ ) + : flags( flags_ ) + , pView( pView_ ) {} + vk::IOSSurfaceCreateInfoMVK & operator=( vk::IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::IOSSurfaceCreateInfoMVK ) - sizeof( vk::StructureType ) ); + return *this; + } + IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::IOSSurfaceCreateInfoMVK( rhs ) - {} + { + *this = rhs; + } IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::IOSSurfaceCreateInfoMVK::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38273,8 +35545,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::IOSSurfaceCreateInfoMVK::sType; + public: + const vk::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; + const void* pNext = nullptr; + vk::IOSSurfaceCreateFlagsMVK flags; + const void* pView; }; static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -38297,12 +35572,12 @@ namespace VULKAN_HPP_NAMESPACE ImageBlit( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageBlit& operator=( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -38378,12 +35653,12 @@ namespace VULKAN_HPP_NAMESPACE ImageCopy( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageCopy& operator=( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -38451,71 +35726,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(), - vk::ImageType imageType_ = vk::ImageType::e1D, - vk::Format format_ = vk::Format::eUndefined, - vk::Extent3D extent_ = vk::Extent3D(), - uint32_t mipLevels_ = 0, - uint32_t arrayLayers_ = 0, - vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1, - vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal, - vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), - vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr, - vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , imageType( imageType_ ) - , format( format_ ) - , extent( extent_ ) - , mipLevels( mipLevels_ ) - , arrayLayers( arrayLayers_ ) - , samples( samples_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , initialLayout( initialLayout_ ) - {} - - ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageCreateInfo; - const void* pNext = nullptr; - vk::ImageCreateFlags flags; - vk::ImageType imageType; - vk::Format format; - vk::Extent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - vk::SampleCountFlagBits samples; - vk::ImageTiling tiling; - vk::ImageUsageFlags usage; - vk::SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - vk::ImageLayout initialLayout; - }; - static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ImageCreateInfo : public layout::ImageCreateInfo + struct ImageCreateInfo { VULKAN_HPP_CONSTEXPR ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(), vk::ImageType imageType_ = vk::ImageType::e1D, @@ -38530,16 +35741,35 @@ namespace VULKAN_HPP_NAMESPACE uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : layout::ImageCreateInfo( flags_, imageType_, format_, extent_, mipLevels_, arrayLayers_, samples_, tiling_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, initialLayout_ ) + : flags( flags_ ) + , imageType( imageType_ ) + , format( format_ ) + , extent( extent_ ) + , mipLevels( mipLevels_ ) + , arrayLayers( arrayLayers_ ) + , samples( samples_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + , initialLayout( initialLayout_ ) {} + vk::ImageCreateInfo & operator=( vk::ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageCreateInfo( rhs ) - {} + { + *this = rhs; + } ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38661,25 +35891,48 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eImageCreateInfo; + const void* pNext = nullptr; + vk::ImageCreateFlags flags; + vk::ImageType imageType; + vk::Format format; + vk::Extent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + vk::SampleCountFlagBits samples; + vk::ImageTiling tiling; + vk::ImageUsageFlags usage; + vk::SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + vk::ImageLayout initialLayout; }; static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct SubresourceLayout { - SubresourceLayout() VULKAN_HPP_NOEXCEPT + SubresourceLayout( vk::DeviceSize offset_ = 0, + vk::DeviceSize size_ = 0, + vk::DeviceSize rowPitch_ = 0, + vk::DeviceSize arrayPitch_ = 0, + vk::DeviceSize depthPitch_ = 0 ) VULKAN_HPP_NOEXCEPT + : offset( offset_ ) + , size( size_ ) + , rowPitch( rowPitch_ ) + , arrayPitch( arrayPitch_ ) + , depthPitch( depthPitch_ ) {} SubresourceLayout( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SubresourceLayout& operator=( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -38717,55 +35970,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageDrmFormatModifierExplicitCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0, - uint32_t drmFormatModifierPlaneCount_ = 0, - const vk::SubresourceLayout* pPlaneLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : drmFormatModifier( drmFormatModifier_ ) - , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ) - , pPlaneLayouts( pPlaneLayouts_ ) - {} - - ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; - const void* pNext = nullptr; - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - const vk::SubresourceLayout* pPlaneLayouts; - }; - static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageDrmFormatModifierExplicitCreateInfoEXT : public layout::ImageDrmFormatModifierExplicitCreateInfoEXT + struct ImageDrmFormatModifierExplicitCreateInfoEXT { VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0, uint32_t drmFormatModifierPlaneCount_ = 0, const vk::SubresourceLayout* pPlaneLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( drmFormatModifier_, drmFormatModifierPlaneCount_, pPlaneLayouts_ ) + : drmFormatModifier( drmFormatModifier_ ) + , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ) + , pPlaneLayouts( pPlaneLayouts_ ) {} + vk::ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( vk::ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierExplicitCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageDrmFormatModifierExplicitCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38817,57 +36045,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageDrmFormatModifierExplicitCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; + const void* pNext = nullptr; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const vk::SubresourceLayout* pPlaneLayouts; }; static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageDrmFormatModifierListCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0, - const uint64_t* pDrmFormatModifiers_ = nullptr ) VULKAN_HPP_NOEXCEPT - : drmFormatModifierCount( drmFormatModifierCount_ ) - , pDrmFormatModifiers( pDrmFormatModifiers_ ) - {} - - ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; - const void* pNext = nullptr; - uint32_t drmFormatModifierCount; - const uint64_t* pDrmFormatModifiers; - }; - static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageDrmFormatModifierListCreateInfoEXT : public layout::ImageDrmFormatModifierListCreateInfoEXT + struct ImageDrmFormatModifierListCreateInfoEXT { VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0, const uint64_t* pDrmFormatModifiers_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierListCreateInfoEXT( drmFormatModifierCount_, pDrmFormatModifiers_ ) + : drmFormatModifierCount( drmFormatModifierCount_ ) + , pDrmFormatModifiers( pDrmFormatModifiers_ ) {} + vk::ImageDrmFormatModifierListCreateInfoEXT & operator=( vk::ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierListCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierListCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageDrmFormatModifierListCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38912,52 +36121,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageDrmFormatModifierListCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; + const void* pNext = nullptr; + uint32_t drmFormatModifierCount; + const uint64_t* pDrmFormatModifiers; }; static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ImageDrmFormatModifierPropertiesEXT { - struct ImageDrmFormatModifierPropertiesEXT - { - protected: - ImageDrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT; - void* pNext = nullptr; - uint64_t drmFormatModifier; - }; - static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageDrmFormatModifierPropertiesEXT : public layout::ImageDrmFormatModifierPropertiesEXT - { - ImageDrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierPropertiesEXT() + ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = 0 ) VULKAN_HPP_NOEXCEPT + : drmFormatModifier( drmFormatModifier_ ) {} + vk::ImageDrmFormatModifierPropertiesEXT & operator=( vk::ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierPropertiesEXT( rhs ) - {} + { + *this = rhs; + } ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageDrmFormatModifierPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38983,57 +36175,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageDrmFormatModifierPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT; + void* pNext = nullptr; + uint64_t drmFormatModifier; }; static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageFormatListCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, - const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT - : viewFormatCount( viewFormatCount_ ) - , pViewFormats( pViewFormats_ ) - {} - - ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageFormatListCreateInfoKHR; - const void* pNext = nullptr; - uint32_t viewFormatCount; - const vk::Format* pViewFormats; - }; - static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImageFormatListCreateInfoKHR : public layout::ImageFormatListCreateInfoKHR + struct ImageFormatListCreateInfoKHR { VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImageFormatListCreateInfoKHR( viewFormatCount_, pViewFormats_ ) + : viewFormatCount( viewFormatCount_ ) + , pViewFormats( pViewFormats_ ) {} + vk::ImageFormatListCreateInfoKHR & operator=( vk::ImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageFormatListCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageFormatListCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageFormatListCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39078,52 +36249,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageFormatListCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImageFormatListCreateInfoKHR; + const void* pNext = nullptr; + uint32_t viewFormatCount; + const vk::Format* pViewFormats; }; static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ImageFormatProperties2 { - struct ImageFormatProperties2 - { - protected: - ImageFormatProperties2() VULKAN_HPP_NOEXCEPT - {} - - ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageFormatProperties2; - void* pNext = nullptr; - vk::ImageFormatProperties imageFormatProperties; - }; - static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct ImageFormatProperties2 : public layout::ImageFormatProperties2 - { - ImageFormatProperties2() VULKAN_HPP_NOEXCEPT - : layout::ImageFormatProperties2() + ImageFormatProperties2( vk::ImageFormatProperties imageFormatProperties_ = vk::ImageFormatProperties() ) VULKAN_HPP_NOEXCEPT + : imageFormatProperties( imageFormatProperties_ ) {} + vk::ImageFormatProperties2 & operator=( vk::ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageFormatProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageFormatProperties2( rhs ) - {} + { + *this = rhs; + } ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageFormatProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39149,8 +36303,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageFormatProperties2::sType; + public: + const vk::StructureType sType = StructureType::eImageFormatProperties2; + void* pNext = nullptr; + vk::ImageFormatProperties imageFormatProperties; }; static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -39171,12 +36327,12 @@ namespace VULKAN_HPP_NAMESPACE ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -39244,56 +36400,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageMemoryBarrier - { - protected: - VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), - vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), - vk::ImageLayout oldLayout_ = vk::ImageLayout::eUndefined, - vk::ImageLayout newLayout_ = vk::ImageLayout::eUndefined, - uint32_t srcQueueFamilyIndex_ = 0, - uint32_t dstQueueFamilyIndex_ = 0, - vk::Image image_ = vk::Image(), - vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , oldLayout( oldLayout_ ) - , newLayout( newLayout_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , image( image_ ) - , subresourceRange( subresourceRange_ ) - {} - - ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageMemoryBarrier; - const void* pNext = nullptr; - vk::AccessFlags srcAccessMask; - vk::AccessFlags dstAccessMask; - vk::ImageLayout oldLayout; - vk::ImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - vk::Image image; - vk::ImageSubresourceRange subresourceRange; - }; - static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "layout struct and wrapper have different size!" ); - } - - struct ImageMemoryBarrier : public layout::ImageMemoryBarrier + struct ImageMemoryBarrier { VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), @@ -39303,16 +36410,30 @@ namespace VULKAN_HPP_NAMESPACE uint32_t dstQueueFamilyIndex_ = 0, vk::Image image_ = vk::Image(), vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT - : layout::ImageMemoryBarrier( srcAccessMask_, dstAccessMask_, oldLayout_, newLayout_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, image_, subresourceRange_ ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , oldLayout( oldLayout_ ) + , newLayout( newLayout_ ) + , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) + , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) + , image( image_ ) + , subresourceRange( subresourceRange_ ) {} + vk::ImageMemoryBarrier & operator=( vk::ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageMemoryBarrier ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageMemoryBarrier( rhs ) - {} + { + *this = rhs; + } ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageMemoryBarrier::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39399,53 +36520,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageMemoryBarrier::sType; + public: + const vk::StructureType sType = StructureType::eImageMemoryBarrier; + const void* pNext = nullptr; + vk::AccessFlags srcAccessMask; + vk::AccessFlags dstAccessMask; + vk::ImageLayout oldLayout; + vk::ImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + vk::Image image; + vk::ImageSubresourceRange subresourceRange; }; static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageMemoryRequirementsInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - {} - - ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageMemoryRequirementsInfo2; - const void* pNext = nullptr; - vk::Image image; - }; - static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct ImageMemoryRequirementsInfo2 : public layout::ImageMemoryRequirementsInfo2 + struct ImageMemoryRequirementsInfo2 { VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT - : layout::ImageMemoryRequirementsInfo2( image_ ) + : image( image_ ) {} + vk::ImageMemoryRequirementsInfo2 & operator=( vk::ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageMemoryRequirementsInfo2( rhs ) - {} + { + *this = rhs; + } ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageMemoryRequirementsInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39483,59 +36592,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageMemoryRequirementsInfo2::sType; + public: + const vk::StructureType sType = StructureType::eImageMemoryRequirementsInfo2; + const void* pNext = nullptr; + vk::Image image; }; static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_FUCHSIA - namespace layout - { - struct ImagePipeSurfaceCreateInfoFUCHSIA - { - protected: - VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(), - zx_handle_t imagePipeHandle_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , imagePipeHandle( imagePipeHandle_ ) - {} - - ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; - const void* pNext = nullptr; - vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags; - zx_handle_t imagePipeHandle; - }; - static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "layout struct and wrapper have different size!" ); - } - - struct ImagePipeSurfaceCreateInfoFUCHSIA : public layout::ImagePipeSurfaceCreateInfoFUCHSIA + struct ImagePipeSurfaceCreateInfoFUCHSIA { VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(), zx_handle_t imagePipeHandle_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImagePipeSurfaceCreateInfoFUCHSIA( flags_, imagePipeHandle_ ) + : flags( flags_ ) + , imagePipeHandle( imagePipeHandle_ ) {} + vk::ImagePipeSurfaceCreateInfoFUCHSIA & operator=( vk::ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImagePipeSurfaceCreateInfoFUCHSIA ) - sizeof( vk::StructureType ) ); + return *this; + } + ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImagePipeSurfaceCreateInfoFUCHSIA( rhs ) - {} + { + *this = rhs; + } ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImagePipeSurfaceCreateInfoFUCHSIA::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39580,54 +36668,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImagePipeSurfaceCreateInfoFUCHSIA::sType; + public: + const vk::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; + const void* pNext = nullptr; + vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags; + zx_handle_t imagePipeHandle; }; static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_FUCHSIA*/ - namespace layout - { - struct ImagePlaneMemoryRequirementsInfo - { - protected: - VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT - : planeAspect( planeAspect_ ) - {} - - ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; - const void* pNext = nullptr; - vk::ImageAspectFlagBits planeAspect; - }; - static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "layout struct and wrapper have different size!" ); - } - - struct ImagePlaneMemoryRequirementsInfo : public layout::ImagePlaneMemoryRequirementsInfo + struct ImagePlaneMemoryRequirementsInfo { VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT - : layout::ImagePlaneMemoryRequirementsInfo( planeAspect_ ) + : planeAspect( planeAspect_ ) {} + vk::ImagePlaneMemoryRequirementsInfo & operator=( vk::ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImagePlaneMemoryRequirementsInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImagePlaneMemoryRequirementsInfo( rhs ) - {} + { + *this = rhs; + } ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImagePlaneMemoryRequirementsInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39665,8 +36735,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImagePlaneMemoryRequirementsInfo::sType; + public: + const vk::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; + const void* pNext = nullptr; + vk::ImageAspectFlagBits planeAspect; }; static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -39687,12 +36759,12 @@ namespace VULKAN_HPP_NAMESPACE ImageResolve( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageResolve& operator=( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -39760,47 +36832,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageSparseMemoryRequirementsInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - {} - - ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; - const void* pNext = nullptr; - vk::Image image; - }; - static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct ImageSparseMemoryRequirementsInfo2 : public layout::ImageSparseMemoryRequirementsInfo2 + struct ImageSparseMemoryRequirementsInfo2 { VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT - : layout::ImageSparseMemoryRequirementsInfo2( image_ ) + : image( image_ ) {} + vk::ImageSparseMemoryRequirementsInfo2 & operator=( vk::ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageSparseMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageSparseMemoryRequirementsInfo2( rhs ) - {} + { + *this = rhs; + } ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageSparseMemoryRequirementsInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39838,53 +36889,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageSparseMemoryRequirementsInfo2::sType; + public: + const vk::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; + const void* pNext = nullptr; + vk::Image image; }; static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageStencilUsageCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT - : stencilUsage( stencilUsage_ ) - {} - - ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT; - const void* pNext = nullptr; - vk::ImageUsageFlags stencilUsage; - }; - static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageStencilUsageCreateInfoEXT : public layout::ImageStencilUsageCreateInfoEXT + struct ImageStencilUsageCreateInfoEXT { VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ImageStencilUsageCreateInfoEXT( stencilUsage_ ) + : stencilUsage( stencilUsage_ ) {} + vk::ImageStencilUsageCreateInfoEXT & operator=( vk::ImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageStencilUsageCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageStencilUsageCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageStencilUsageCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39922,53 +36954,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageStencilUsageCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT; + const void* pNext = nullptr; + vk::ImageUsageFlags stencilUsage; }; static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageSwapchainCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT - : swapchain( swapchain_ ) - {} - - ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; - const void* pNext = nullptr; - vk::SwapchainKHR swapchain; - }; - static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImageSwapchainCreateInfoKHR : public layout::ImageSwapchainCreateInfoKHR + struct ImageSwapchainCreateInfoKHR { VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT - : layout::ImageSwapchainCreateInfoKHR( swapchain_ ) + : swapchain( swapchain_ ) {} + vk::ImageSwapchainCreateInfoKHR & operator=( vk::ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageSwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageSwapchainCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageSwapchainCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40006,53 +37019,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageSwapchainCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; + const void* pNext = nullptr; + vk::SwapchainKHR swapchain; }; static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageViewASTCDecodeModeEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined ) VULKAN_HPP_NOEXCEPT - : decodeMode( decodeMode_ ) - {} - - ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT; - const void* pNext = nullptr; - vk::Format decodeMode; - }; - static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageViewASTCDecodeModeEXT : public layout::ImageViewASTCDecodeModeEXT + struct ImageViewASTCDecodeModeEXT { VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewASTCDecodeModeEXT( decodeMode_ ) + : decodeMode( decodeMode_ ) {} + vk::ImageViewASTCDecodeModeEXT & operator=( vk::ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewASTCDecodeModeEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewASTCDecodeModeEXT( rhs ) - {} + { + *this = rhs; + } ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageViewASTCDecodeModeEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40090,56 +37084,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageViewASTCDecodeModeEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT; + const void* pNext = nullptr; + vk::Format decodeMode; }; static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageViewCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(), - vk::Image image_ = vk::Image(), - vk::ImageViewType viewType_ = vk::ImageViewType::e1D, - vk::Format format_ = vk::Format::eUndefined, - vk::ComponentMapping components_ = vk::ComponentMapping(), - vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , image( image_ ) - , viewType( viewType_ ) - , format( format_ ) - , components( components_ ) - , subresourceRange( subresourceRange_ ) - {} - - ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageViewCreateInfo; - const void* pNext = nullptr; - vk::ImageViewCreateFlags flags; - vk::Image image; - vk::ImageViewType viewType; - vk::Format format; - vk::ComponentMapping components; - vk::ImageSubresourceRange subresourceRange; - }; - static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ImageViewCreateInfo : public layout::ImageViewCreateInfo + struct ImageViewCreateInfo { VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(), vk::Image image_ = vk::Image(), @@ -40147,16 +37100,28 @@ namespace VULKAN_HPP_NAMESPACE vk::Format format_ = vk::Format::eUndefined, vk::ComponentMapping components_ = vk::ComponentMapping(), vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewCreateInfo( flags_, image_, viewType_, format_, components_, subresourceRange_ ) + : flags( flags_ ) + , image( image_ ) + , viewType( viewType_ ) + , format( format_ ) + , components( components_ ) + , subresourceRange( subresourceRange_ ) {} + vk::ImageViewCreateInfo & operator=( vk::ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewCreateInfo( rhs ) - {} + { + *this = rhs; + } ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageViewCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40229,61 +37194,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageViewCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eImageViewCreateInfo; + const void* pNext = nullptr; + vk::ImageViewCreateFlags flags; + vk::Image image; + vk::ImageViewType viewType; + vk::Format format; + vk::ComponentMapping components; + vk::ImageSubresourceRange subresourceRange; }; static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageViewHandleInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(), - vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler, - vk::Sampler sampler_ = vk::Sampler() ) VULKAN_HPP_NOEXCEPT - : imageView( imageView_ ) - , descriptorType( descriptorType_ ) - , sampler( sampler_ ) - {} - - ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageViewHandleInfoNVX; - const void* pNext = nullptr; - vk::ImageView imageView; - vk::DescriptorType descriptorType; - vk::Sampler sampler; - }; - static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct ImageViewHandleInfoNVX : public layout::ImageViewHandleInfoNVX + struct ImageViewHandleInfoNVX { VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(), vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler, vk::Sampler sampler_ = vk::Sampler() ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewHandleInfoNVX( imageView_, descriptorType_, sampler_ ) + : imageView( imageView_ ) + , descriptorType( descriptorType_ ) + , sampler( sampler_ ) {} + vk::ImageViewHandleInfoNVX & operator=( vk::ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewHandleInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewHandleInfoNVX( rhs ) - {} + { + *this = rhs; + } ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageViewHandleInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40335,53 +37282,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageViewHandleInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eImageViewHandleInfoNVX; + const void* pNext = nullptr; + vk::ImageView imageView; + vk::DescriptorType descriptorType; + vk::Sampler sampler; }; static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageViewUsageCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT - : usage( usage_ ) - {} - - ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageViewUsageCreateInfo; - const void* pNext = nullptr; - vk::ImageUsageFlags usage; - }; - static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ImageViewUsageCreateInfo : public layout::ImageViewUsageCreateInfo + struct ImageViewUsageCreateInfo { VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewUsageCreateInfo( usage_ ) + : usage( usage_ ) {} + vk::ImageViewUsageCreateInfo & operator=( vk::ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewUsageCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewUsageCreateInfo( rhs ) - {} + { + *this = rhs; + } ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageViewUsageCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40419,55 +37349,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageViewUsageCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eImageViewUsageCreateInfo; + const void* pNext = nullptr; + vk::ImageUsageFlags usage; }; static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout - { - struct ImportAndroidHardwareBufferInfoANDROID - { - protected: - VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - {} - - ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; - const void* pNext = nullptr; - struct AHardwareBuffer* buffer; - }; - static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "layout struct and wrapper have different size!" ); - } - - struct ImportAndroidHardwareBufferInfoANDROID : public layout::ImportAndroidHardwareBufferInfoANDROID + struct ImportAndroidHardwareBufferInfoANDROID { VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportAndroidHardwareBufferInfoANDROID( buffer_ ) + : buffer( buffer_ ) {} + vk::ImportAndroidHardwareBufferInfoANDROID & operator=( vk::ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportAndroidHardwareBufferInfoANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportAndroidHardwareBufferInfoANDROID( rhs ) - {} + { + *this = rhs; + } ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportAndroidHardwareBufferInfoANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40505,66 +37416,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportAndroidHardwareBufferInfoANDROID::sType; + public: + const vk::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; + const void* pNext = nullptr; + struct AHardwareBuffer* buffer; }; static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - namespace layout - { - struct ImportFenceFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(), - vk::FenceImportFlags flags_ = vk::FenceImportFlags(), - vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : fence( fence_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , fd( fd_ ) - {} - - ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportFenceFdInfoKHR; - const void* pNext = nullptr; - vk::Fence fence; - vk::FenceImportFlags flags; - vk::ExternalFenceHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportFenceFdInfoKHR : public layout::ImportFenceFdInfoKHR + struct ImportFenceFdInfoKHR { VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(), vk::FenceImportFlags flags_ = vk::FenceImportFlags(), vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd, int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImportFenceFdInfoKHR( fence_, flags_, handleType_, fd_ ) + : fence( fence_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , fd( fd_ ) {} + vk::ImportFenceFdInfoKHR & operator=( vk::ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportFenceFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportFenceFdInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportFenceFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40623,71 +37509,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportFenceFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportFenceFdInfoKHR; + const void* pNext = nullptr; + vk::Fence fence; + vk::FenceImportFlags flags; + vk::ExternalFenceHandleTypeFlagBits handleType; + int fd; }; static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ImportFenceWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(), - vk::FenceImportFlags flags_ = vk::FenceImportFlags(), - vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : fence( fence_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - {} - - ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::Fence fence; - vk::FenceImportFlags flags; - vk::ExternalFenceHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportFenceWin32HandleInfoKHR : public layout::ImportFenceWin32HandleInfoKHR + struct ImportFenceWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(), vk::FenceImportFlags flags_ = vk::FenceImportFlags(), vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportFenceWin32HandleInfoKHR( fence_, flags_, handleType_, handle_, name_ ) + : fence( fence_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) {} + vk::ImportFenceWin32HandleInfoKHR & operator=( vk::ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportFenceWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportFenceWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportFenceWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40753,58 +37615,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportFenceWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::Fence fence; + vk::FenceImportFlags flags; + vk::ExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; }; static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct ImportMemoryFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - , fd( fd_ ) - {} - - ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportMemoryFdInfoKHR; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportMemoryFdInfoKHR : public layout::ImportMemoryFdInfoKHR + struct ImportMemoryFdInfoKHR { VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryFdInfoKHR( handleType_, fd_ ) + : handleType( handleType_ ) + , fd( fd_ ) {} + vk::ImportMemoryFdInfoKHR & operator=( vk::ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryFdInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportMemoryFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40849,57 +37694,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportMemoryFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportMemoryFdInfoKHR; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagBits handleType; + int fd; }; static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImportMemoryHostPointerInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - void* pHostPointer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - , pHostPointer( pHostPointer_ ) - {} - - ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagBits handleType; - void* pHostPointer; - }; - static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImportMemoryHostPointerInfoEXT : public layout::ImportMemoryHostPointerInfoEXT + struct ImportMemoryHostPointerInfoEXT { VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, void* pHostPointer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryHostPointerInfoEXT( handleType_, pHostPointer_ ) + : handleType( handleType_ ) + , pHostPointer( pHostPointer_ ) {} + vk::ImportMemoryHostPointerInfoEXT & operator=( vk::ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryHostPointerInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryHostPointerInfoEXT( rhs ) - {} + { + *this = rhs; + } ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportMemoryHostPointerInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40944,63 +37769,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportMemoryHostPointerInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; }; static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ImportMemoryWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - {} - - ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportMemoryWin32HandleInfoKHR : public layout::ImportMemoryWin32HandleInfoKHR + struct ImportMemoryWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryWin32HandleInfoKHR( handleType_, handle_, name_ ) + : handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) {} + vk::ImportMemoryWin32HandleInfoKHR & operator=( vk::ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportMemoryWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41052,8 +37855,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportMemoryWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; }; static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -41061,51 +37868,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ImportMemoryWin32HandleInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(), - HANDLE handle_ = 0 ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - , handle( handle_ ) - {} - - ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagsNV handleType; - HANDLE handle; - }; - static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct ImportMemoryWin32HandleInfoNV : public layout::ImportMemoryWin32HandleInfoNV + struct ImportMemoryWin32HandleInfoNV { VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryWin32HandleInfoNV( handleType_, handle_ ) + : handleType( handleType_ ) + , handle( handle_ ) {} + vk::ImportMemoryWin32HandleInfoNV & operator=( vk::ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryWin32HandleInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryWin32HandleInfoNV( rhs ) - {} + { + *this = rhs; + } ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportMemoryWin32HandleInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41150,66 +37934,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportMemoryWin32HandleInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; }; static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct ImportSemaphoreFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(), - vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , fd( fd_ ) - {} - - ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - vk::SemaphoreImportFlags flags; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportSemaphoreFdInfoKHR : public layout::ImportSemaphoreFdInfoKHR + struct ImportSemaphoreFdInfoKHR { VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(), vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImportSemaphoreFdInfoKHR( semaphore_, flags_, handleType_, fd_ ) + : semaphore( semaphore_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , fd( fd_ ) {} + vk::ImportSemaphoreFdInfoKHR & operator=( vk::ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportSemaphoreFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportSemaphoreFdInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportSemaphoreFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41268,71 +38028,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportSemaphoreFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + vk::SemaphoreImportFlags flags; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; + int fd; }; static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ImportSemaphoreWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(), - vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - {} - - ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - vk::SemaphoreImportFlags flags; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportSemaphoreWin32HandleInfoKHR : public layout::ImportSemaphoreWin32HandleInfoKHR + struct ImportSemaphoreWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(), vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportSemaphoreWin32HandleInfoKHR( semaphore_, flags_, handleType_, handle_, name_ ) + : semaphore( semaphore_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) {} + vk::ImportSemaphoreWin32HandleInfoKHR & operator=( vk::ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportSemaphoreWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportSemaphoreWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportSemaphoreWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41398,8 +38134,14 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportSemaphoreWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + vk::SemaphoreImportFlags flags; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; }; static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -41419,12 +38161,12 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -41484,59 +38226,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct IndirectCommandsLayoutCreateInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, - vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(), - uint32_t tokenCount_ = 0, - const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pipelineBindPoint( pipelineBindPoint_ ) - , flags( flags_ ) - , tokenCount( tokenCount_ ) - , pTokens( pTokens_ ) - {} - - IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX; - const void* pNext = nullptr; - vk::PipelineBindPoint pipelineBindPoint; - vk::IndirectCommandsLayoutUsageFlagsNVX flags; - uint32_t tokenCount; - const vk::IndirectCommandsLayoutTokenNVX* pTokens; - }; - static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct IndirectCommandsLayoutCreateInfoNVX : public layout::IndirectCommandsLayoutCreateInfoNVX + struct IndirectCommandsLayoutCreateInfoNVX { VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::IndirectCommandsLayoutCreateInfoNVX( pipelineBindPoint_, flags_, tokenCount_, pTokens_ ) + : pipelineBindPoint( pipelineBindPoint_ ) + , flags( flags_ ) + , tokenCount( tokenCount_ ) + , pTokens( pTokens_ ) {} + vk::IndirectCommandsLayoutCreateInfoNVX & operator=( vk::IndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::IndirectCommandsLayoutCreateInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::IndirectCommandsLayoutCreateInfoNVX( rhs ) - {} + { + *this = rhs; + } IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::IndirectCommandsLayoutCreateInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41595,53 +38310,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::IndirectCommandsLayoutCreateInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX; + const void* pNext = nullptr; + vk::PipelineBindPoint pipelineBindPoint; + vk::IndirectCommandsLayoutUsageFlagsNVX flags; + uint32_t tokenCount; + const vk::IndirectCommandsLayoutTokenNVX* pTokens; }; static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct InitializePerformanceApiInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pUserData( pUserData_ ) - {} - - InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL; - const void* pNext = nullptr; - void* pUserData; - }; - static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct InitializePerformanceApiInfoINTEL : public layout::InitializePerformanceApiInfoINTEL + struct InitializePerformanceApiInfoINTEL { VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::InitializePerformanceApiInfoINTEL( pUserData_ ) + : pUserData( pUserData_ ) {} + vk::InitializePerformanceApiInfoINTEL & operator=( vk::InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::InitializePerformanceApiInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::InitializePerformanceApiInfoINTEL( rhs ) - {} + { + *this = rhs; + } InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::InitializePerformanceApiInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41679,8 +38378,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::InitializePerformanceApiInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL; + const void* pNext = nullptr; + void* pUserData; }; static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -41697,12 +38398,12 @@ namespace VULKAN_HPP_NAMESPACE InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -41754,50 +38455,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct InstanceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(), - const vk::ApplicationInfo* pApplicationInfo_ = nullptr, - uint32_t enabledLayerCount_ = 0, - const char* const* ppEnabledLayerNames_ = nullptr, - uint32_t enabledExtensionCount_ = 0, - const char* const* ppEnabledExtensionNames_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pApplicationInfo( pApplicationInfo_ ) - , enabledLayerCount( enabledLayerCount_ ) - , ppEnabledLayerNames( ppEnabledLayerNames_ ) - , enabledExtensionCount( enabledExtensionCount_ ) - , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) - {} - - InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eInstanceCreateInfo; - const void* pNext = nullptr; - vk::InstanceCreateFlags flags; - const vk::ApplicationInfo* pApplicationInfo; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - }; - static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct InstanceCreateInfo : public layout::InstanceCreateInfo + struct InstanceCreateInfo { VULKAN_HPP_CONSTEXPR InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(), const vk::ApplicationInfo* pApplicationInfo_ = nullptr, @@ -41805,16 +38463,28 @@ namespace VULKAN_HPP_NAMESPACE const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::InstanceCreateInfo( flags_, pApplicationInfo_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_ ) + : flags( flags_ ) + , pApplicationInfo( pApplicationInfo_ ) + , enabledLayerCount( enabledLayerCount_ ) + , ppEnabledLayerNames( ppEnabledLayerNames_ ) + , enabledExtensionCount( enabledExtensionCount_ ) + , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) {} + vk::InstanceCreateInfo & operator=( vk::InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::InstanceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::InstanceCreateInfo( rhs ) - {} + { + *this = rhs; + } InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::InstanceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41887,25 +38557,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::InstanceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eInstanceCreateInfo; + const void* pNext = nullptr; + vk::InstanceCreateFlags flags; + const vk::ApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; }; static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct LayerProperties { - LayerProperties() VULKAN_HPP_NOEXCEPT - {} + LayerProperties( std::array const& layerName_ = { { 0 } }, + uint32_t specVersion_ = 0, + uint32_t implementationVersion_ = 0, + std::array const& description_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT + : layerName{} + , specVersion( specVersion_ ) + , implementationVersion( implementationVersion_ ) + , description{} + { + vk::ConstExpressionArrayCopy::copy( layerName, layerName_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } LayerProperties& operator=( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -41943,51 +38630,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_MACOS_MVK - namespace layout - { - struct MacOSSurfaceCreateInfoMVK - { - protected: - VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(), - const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pView( pView_ ) - {} - - MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; - const void* pNext = nullptr; - vk::MacOSSurfaceCreateFlagsMVK flags; - const void* pView; - }; - static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "layout struct and wrapper have different size!" ); - } - - struct MacOSSurfaceCreateInfoMVK : public layout::MacOSSurfaceCreateInfoMVK + struct MacOSSurfaceCreateInfoMVK { VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::MacOSSurfaceCreateInfoMVK( flags_, pView_ ) + : flags( flags_ ) + , pView( pView_ ) {} + vk::MacOSSurfaceCreateInfoMVK & operator=( vk::MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MacOSSurfaceCreateInfoMVK ) - sizeof( vk::StructureType ) ); + return *this; + } + MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MacOSSurfaceCreateInfoMVK( rhs ) - {} + { + *this = rhs; + } MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MacOSSurfaceCreateInfoMVK::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42032,62 +38696,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MacOSSurfaceCreateInfoMVK::sType; + public: + const vk::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; + const void* pNext = nullptr; + vk::MacOSSurfaceCreateFlagsMVK flags; + const void* pView; }; static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_MACOS_MVK*/ - namespace layout - { - struct MappedMemoryRange - { - protected: - VULKAN_HPP_CONSTEXPR MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::DeviceSize offset_ = 0, - vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT - : memory( memory_ ) - , offset( offset_ ) - , size( size_ ) - {} - - MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMappedMemoryRange; - const void* pNext = nullptr; - vk::DeviceMemory memory; - vk::DeviceSize offset; - vk::DeviceSize size; - }; - static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "layout struct and wrapper have different size!" ); - } - - struct MappedMemoryRange : public layout::MappedMemoryRange + struct MappedMemoryRange { VULKAN_HPP_CONSTEXPR MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::DeviceSize offset_ = 0, vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::MappedMemoryRange( memory_, offset_, size_ ) + : memory( memory_ ) + , offset( offset_ ) + , size( size_ ) {} + vk::MappedMemoryRange & operator=( vk::MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MappedMemoryRange ) - sizeof( vk::StructureType ) ); + return *this; + } + MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MappedMemoryRange( rhs ) - {} + { + *this = rhs; + } MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MappedMemoryRange::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42139,57 +38781,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MappedMemoryRange::sType; + public: + const vk::StructureType sType = StructureType::eMappedMemoryRange; + const void* pNext = nullptr; + vk::DeviceMemory memory; + vk::DeviceSize offset; + vk::DeviceSize size; }; static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryAllocateFlagsInfo - { - protected: - VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(), - uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , deviceMask( deviceMask_ ) - {} - - MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryAllocateFlagsInfo; - const void* pNext = nullptr; - vk::MemoryAllocateFlags flags; - uint32_t deviceMask; - }; - static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "layout struct and wrapper have different size!" ); - } - - struct MemoryAllocateFlagsInfo : public layout::MemoryAllocateFlagsInfo + struct MemoryAllocateFlagsInfo { VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(), uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::MemoryAllocateFlagsInfo( flags_, deviceMask_ ) + : flags( flags_ ) + , deviceMask( deviceMask_ ) {} + vk::MemoryAllocateFlagsInfo & operator=( vk::MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryAllocateFlagsInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryAllocateFlagsInfo( rhs ) - {} + { + *this = rhs; + } MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryAllocateFlagsInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42234,57 +38857,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryAllocateFlagsInfo::sType; + public: + const vk::StructureType sType = StructureType::eMemoryAllocateFlagsInfo; + const void* pNext = nullptr; + vk::MemoryAllocateFlags flags; + uint32_t deviceMask; }; static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0, - uint32_t memoryTypeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : allocationSize( allocationSize_ ) - , memoryTypeIndex( memoryTypeIndex_ ) - {} - - MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryAllocateInfo; - const void* pNext = nullptr; - vk::DeviceSize allocationSize; - uint32_t memoryTypeIndex; - }; - static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct MemoryAllocateInfo : public layout::MemoryAllocateInfo + struct MemoryAllocateInfo { VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0, uint32_t memoryTypeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::MemoryAllocateInfo( allocationSize_, memoryTypeIndex_ ) + : allocationSize( allocationSize_ ) + , memoryTypeIndex( memoryTypeIndex_ ) {} + vk::MemoryAllocateInfo & operator=( vk::MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryAllocateInfo( rhs ) - {} + { + *this = rhs; + } MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42329,57 +38932,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eMemoryAllocateInfo; + const void* pNext = nullptr; + vk::DeviceSize allocationSize; + uint32_t memoryTypeIndex; }; static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryBarrier - { - protected: - VULKAN_HPP_CONSTEXPR MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), - vk::AccessFlags dstAccessMask_ = vk::AccessFlags() ) VULKAN_HPP_NOEXCEPT - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - {} - - MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryBarrier; - const void* pNext = nullptr; - vk::AccessFlags srcAccessMask; - vk::AccessFlags dstAccessMask; - }; - static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "layout struct and wrapper have different size!" ); - } - - struct MemoryBarrier : public layout::MemoryBarrier + struct MemoryBarrier { VULKAN_HPP_CONSTEXPR MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), vk::AccessFlags dstAccessMask_ = vk::AccessFlags() ) VULKAN_HPP_NOEXCEPT - : layout::MemoryBarrier( srcAccessMask_, dstAccessMask_ ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) {} + vk::MemoryBarrier & operator=( vk::MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryBarrier ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryBarrier( rhs ) - {} + { + *this = rhs; + } MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryBarrier::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42424,57 +39007,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryBarrier::sType; + public: + const vk::StructureType sType = StructureType::eMemoryBarrier; + const void* pNext = nullptr; + vk::AccessFlags srcAccessMask; + vk::AccessFlags dstAccessMask; }; static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryDedicatedAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(), - vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - , buffer( buffer_ ) - {} - - MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; - const void* pNext = nullptr; - vk::Image image; - vk::Buffer buffer; - }; - static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct MemoryDedicatedAllocateInfo : public layout::MemoryDedicatedAllocateInfo + struct MemoryDedicatedAllocateInfo { VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(), vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : layout::MemoryDedicatedAllocateInfo( image_, buffer_ ) + : image( image_ ) + , buffer( buffer_ ) {} + vk::MemoryDedicatedAllocateInfo & operator=( vk::MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryDedicatedAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryDedicatedAllocateInfo( rhs ) - {} + { + *this = rhs; + } MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryDedicatedAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42519,53 +39082,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryDedicatedAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; + const void* pNext = nullptr; + vk::Image image; + vk::Buffer buffer; }; static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct MemoryDedicatedRequirements { - struct MemoryDedicatedRequirements - { - protected: - MemoryDedicatedRequirements() VULKAN_HPP_NOEXCEPT - {} - - MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryDedicatedRequirements; - void* pNext = nullptr; - vk::Bool32 prefersDedicatedAllocation; - vk::Bool32 requiresDedicatedAllocation; - }; - static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "layout struct and wrapper have different size!" ); - } - - struct MemoryDedicatedRequirements : public layout::MemoryDedicatedRequirements - { - MemoryDedicatedRequirements() VULKAN_HPP_NOEXCEPT - : layout::MemoryDedicatedRequirements() + MemoryDedicatedRequirements( vk::Bool32 prefersDedicatedAllocation_ = 0, + vk::Bool32 requiresDedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT + : prefersDedicatedAllocation( prefersDedicatedAllocation_ ) + , requiresDedicatedAllocation( requiresDedicatedAllocation_ ) {} + vk::MemoryDedicatedRequirements & operator=( vk::MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryDedicatedRequirements ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryDedicatedRequirements( rhs ) - {} + { + *this = rhs; + } MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryDedicatedRequirements::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42592,52 +39139,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryDedicatedRequirements::sType; + public: + const vk::StructureType sType = StructureType::eMemoryDedicatedRequirements; + void* pNext = nullptr; + vk::Bool32 prefersDedicatedAllocation; + vk::Bool32 requiresDedicatedAllocation; }; static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct MemoryFdPropertiesKHR { - struct MemoryFdPropertiesKHR - { - protected: - MemoryFdPropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryFdPropertiesKHR; - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct MemoryFdPropertiesKHR : public layout::MemoryFdPropertiesKHR - { - MemoryFdPropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::MemoryFdPropertiesKHR() + MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : memoryTypeBits( memoryTypeBits_ ) {} + vk::MemoryFdPropertiesKHR & operator=( vk::MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryFdPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryFdPropertiesKHR( rhs ) - {} + { + *this = rhs; + } MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryFdPropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42663,55 +39193,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryFdPropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eMemoryFdPropertiesKHR; + void* pNext = nullptr; + uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout - { - struct MemoryGetAndroidHardwareBufferInfoANDROID - { - protected: - VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() ) VULKAN_HPP_NOEXCEPT - : memory( memory_ ) - {} - - MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; - const void* pNext = nullptr; - vk::DeviceMemory memory; - }; - static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "layout struct and wrapper have different size!" ); - } - - struct MemoryGetAndroidHardwareBufferInfoANDROID : public layout::MemoryGetAndroidHardwareBufferInfoANDROID + struct MemoryGetAndroidHardwareBufferInfoANDROID { VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetAndroidHardwareBufferInfoANDROID( memory_ ) + : memory( memory_ ) {} + vk::MemoryGetAndroidHardwareBufferInfoANDROID & operator=( vk::MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetAndroidHardwareBufferInfoANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetAndroidHardwareBufferInfoANDROID( rhs ) - {} + { + *this = rhs; + } MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryGetAndroidHardwareBufferInfoANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42749,58 +39260,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryGetAndroidHardwareBufferInfoANDROID::sType; + public: + const vk::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; + const void* pNext = nullptr; + vk::DeviceMemory memory; }; static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - namespace layout - { - struct MemoryGetFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : memory( memory_ ) - , handleType( handleType_ ) - {} - - MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryGetFdInfoKHR; - const void* pNext = nullptr; - vk::DeviceMemory memory; - vk::ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct MemoryGetFdInfoKHR : public layout::MemoryGetFdInfoKHR + struct MemoryGetFdInfoKHR { VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetFdInfoKHR( memory_, handleType_ ) + : memory( memory_ ) + , handleType( handleType_ ) {} + vk::MemoryGetFdInfoKHR & operator=( vk::MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetFdInfoKHR( rhs ) - {} + { + *this = rhs; + } MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryGetFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42845,59 +39335,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryGetFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eMemoryGetFdInfoKHR; + const void* pNext = nullptr; + vk::DeviceMemory memory; + vk::ExternalMemoryHandleTypeFlagBits handleType; }; static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct MemoryGetWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : memory( memory_ ) - , handleType( handleType_ ) - {} - - MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::DeviceMemory memory; - vk::ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct MemoryGetWin32HandleInfoKHR : public layout::MemoryGetWin32HandleInfoKHR + struct MemoryGetWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetWin32HandleInfoKHR( memory_, handleType_ ) + : memory( memory_ ) + , handleType( handleType_ ) {} + vk::MemoryGetWin32HandleInfoKHR & operator=( vk::MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryGetWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42942,8 +39412,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryGetWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::DeviceMemory memory; + vk::ExternalMemoryHandleTypeFlagBits handleType; }; static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -42951,17 +39424,20 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryHeap { - MemoryHeap() VULKAN_HPP_NOEXCEPT + MemoryHeap( vk::DeviceSize size_ = 0, + vk::MemoryHeapFlags flags_ = vk::MemoryHeapFlags() ) VULKAN_HPP_NOEXCEPT + : size( size_ ) + , flags( flags_ ) {} MemoryHeap( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } MemoryHeap& operator=( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -42993,46 +39469,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct MemoryHostPointerPropertiesEXT { - struct MemoryHostPointerPropertiesEXT - { - protected: - MemoryHostPointerPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct MemoryHostPointerPropertiesEXT : public layout::MemoryHostPointerPropertiesEXT - { - MemoryHostPointerPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::MemoryHostPointerPropertiesEXT() + MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : memoryTypeBits( memoryTypeBits_ ) {} + vk::MemoryHostPointerPropertiesEXT & operator=( vk::MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryHostPointerPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryHostPointerPropertiesEXT( rhs ) - {} + { + *this = rhs; + } MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryHostPointerPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43058,53 +39514,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryHostPointerPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; + void* pNext = nullptr; + uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryPriorityAllocateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = 0 ) VULKAN_HPP_NOEXCEPT - : priority( priority_ ) - {} - - MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT; - const void* pNext = nullptr; - float priority; - }; - static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct MemoryPriorityAllocateInfoEXT : public layout::MemoryPriorityAllocateInfoEXT + struct MemoryPriorityAllocateInfoEXT { VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::MemoryPriorityAllocateInfoEXT( priority_ ) + : priority( priority_ ) {} + vk::MemoryPriorityAllocateInfoEXT & operator=( vk::MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryPriorityAllocateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryPriorityAllocateInfoEXT( rhs ) - {} + { + *this = rhs; + } MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryPriorityAllocateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43142,25 +39579,32 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryPriorityAllocateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT; + const void* pNext = nullptr; + float priority; }; static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct MemoryRequirements { - MemoryRequirements() VULKAN_HPP_NOEXCEPT + MemoryRequirements( vk::DeviceSize size_ = 0, + vk::DeviceSize alignment_ = 0, + uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : size( size_ ) + , alignment( alignment_ ) + , memoryTypeBits( memoryTypeBits_ ) {} MemoryRequirements( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } MemoryRequirements& operator=( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43194,46 +39638,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct MemoryRequirements2 { - struct MemoryRequirements2 - { - protected: - MemoryRequirements2() VULKAN_HPP_NOEXCEPT - {} - - MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryRequirements2; - void* pNext = nullptr; - vk::MemoryRequirements memoryRequirements; - }; - static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "layout struct and wrapper have different size!" ); - } - - struct MemoryRequirements2 : public layout::MemoryRequirements2 - { - MemoryRequirements2() VULKAN_HPP_NOEXCEPT - : layout::MemoryRequirements2() + MemoryRequirements2( vk::MemoryRequirements memoryRequirements_ = vk::MemoryRequirements() ) VULKAN_HPP_NOEXCEPT + : memoryRequirements( memoryRequirements_ ) {} + vk::MemoryRequirements2 & operator=( vk::MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryRequirements2 ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryRequirements2( rhs ) - {} + { + *this = rhs; + } MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryRequirements2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43259,25 +39683,30 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryRequirements2::sType; + public: + const vk::StructureType sType = StructureType::eMemoryRequirements2; + void* pNext = nullptr; + vk::MemoryRequirements memoryRequirements; }; static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct MemoryType { - MemoryType() VULKAN_HPP_NOEXCEPT + MemoryType( vk::MemoryPropertyFlags propertyFlags_ = vk::MemoryPropertyFlags(), + uint32_t heapIndex_ = 0 ) VULKAN_HPP_NOEXCEPT + : propertyFlags( propertyFlags_ ) + , heapIndex( heapIndex_ ) {} MemoryType( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } MemoryType& operator=( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43311,46 +39740,26 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout + struct MemoryWin32HandlePropertiesKHR { - struct MemoryWin32HandlePropertiesKHR - { - protected: - MemoryWin32HandlePropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct MemoryWin32HandlePropertiesKHR : public layout::MemoryWin32HandlePropertiesKHR - { - MemoryWin32HandlePropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::MemoryWin32HandlePropertiesKHR() + MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : memoryTypeBits( memoryTypeBits_ ) {} + vk::MemoryWin32HandlePropertiesKHR & operator=( vk::MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryWin32HandlePropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryWin32HandlePropertiesKHR( rhs ) - {} + { + *this = rhs; + } MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryWin32HandlePropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43376,8 +39785,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryWin32HandlePropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; + void* pNext = nullptr; + uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -43385,51 +39796,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_METAL_EXT - namespace layout - { - struct MetalSurfaceCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(), - const CAMetalLayer* pLayer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pLayer( pLayer_ ) - {} - - MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT; - const void* pNext = nullptr; - vk::MetalSurfaceCreateFlagsEXT flags; - const CAMetalLayer* pLayer; - }; - static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct MetalSurfaceCreateInfoEXT : public layout::MetalSurfaceCreateInfoEXT + struct MetalSurfaceCreateInfoEXT { VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(), const CAMetalLayer* pLayer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::MetalSurfaceCreateInfoEXT( flags_, pLayer_ ) + : flags( flags_ ) + , pLayer( pLayer_ ) {} + vk::MetalSurfaceCreateInfoEXT & operator=( vk::MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MetalSurfaceCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MetalSurfaceCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MetalSurfaceCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43474,53 +39862,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MetalSurfaceCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT; + const void* pNext = nullptr; + vk::MetalSurfaceCreateFlagsEXT flags; + const CAMetalLayer* pLayer; }; static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_METAL_EXT*/ - namespace layout + struct MultisamplePropertiesEXT { - struct MultisamplePropertiesEXT - { - protected: - MultisamplePropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMultisamplePropertiesEXT; - void* pNext = nullptr; - vk::Extent2D maxSampleLocationGridSize; - }; - static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct MultisamplePropertiesEXT : public layout::MultisamplePropertiesEXT - { - MultisamplePropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::MultisamplePropertiesEXT() + MultisamplePropertiesEXT( vk::Extent2D maxSampleLocationGridSize_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT + : maxSampleLocationGridSize( maxSampleLocationGridSize_ ) {} + vk::MultisamplePropertiesEXT & operator=( vk::MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MultisamplePropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MultisamplePropertiesEXT( rhs ) - {} + { + *this = rhs; + } MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MultisamplePropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43546,65 +39917,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MultisamplePropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::eMultisamplePropertiesEXT; + void* pNext = nullptr; + vk::Extent2D maxSampleLocationGridSize; }; static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ObjectTableCreateInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, - const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, - const uint32_t* pObjectEntryCounts_ = nullptr, - const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, - uint32_t maxUniformBuffersPerDescriptor_ = 0, - uint32_t maxStorageBuffersPerDescriptor_ = 0, - uint32_t maxStorageImagesPerDescriptor_ = 0, - uint32_t maxSampledImagesPerDescriptor_ = 0, - uint32_t maxPipelineLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT - : objectCount( objectCount_ ) - , pObjectEntryTypes( pObjectEntryTypes_ ) - , pObjectEntryCounts( pObjectEntryCounts_ ) - , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) - , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) - , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) - , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) - , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) - , maxPipelineLayouts( maxPipelineLayouts_ ) - {} - - ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eObjectTableCreateInfoNVX; - const void* pNext = nullptr; - uint32_t objectCount; - const vk::ObjectEntryTypeNVX* pObjectEntryTypes; - const uint32_t* pObjectEntryCounts; - const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; - uint32_t maxUniformBuffersPerDescriptor; - uint32_t maxStorageBuffersPerDescriptor; - uint32_t maxStorageImagesPerDescriptor; - uint32_t maxSampledImagesPerDescriptor; - uint32_t maxPipelineLayouts; - }; - static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct ObjectTableCreateInfoNVX : public layout::ObjectTableCreateInfoNVX + struct ObjectTableCreateInfoNVX { VULKAN_HPP_CONSTEXPR ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, @@ -43615,16 +39936,31 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxStorageImagesPerDescriptor_ = 0, uint32_t maxSampledImagesPerDescriptor_ = 0, uint32_t maxPipelineLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ObjectTableCreateInfoNVX( objectCount_, pObjectEntryTypes_, pObjectEntryCounts_, pObjectEntryUsageFlags_, maxUniformBuffersPerDescriptor_, maxStorageBuffersPerDescriptor_, maxStorageImagesPerDescriptor_, maxSampledImagesPerDescriptor_, maxPipelineLayouts_ ) + : objectCount( objectCount_ ) + , pObjectEntryTypes( pObjectEntryTypes_ ) + , pObjectEntryCounts( pObjectEntryCounts_ ) + , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) + , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) + , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) + , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) + , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) + , maxPipelineLayouts( maxPipelineLayouts_ ) {} + vk::ObjectTableCreateInfoNVX & operator=( vk::ObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ObjectTableCreateInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ObjectTableCreateInfoNVX( rhs ) - {} + { + *this = rhs; + } ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ObjectTableCreateInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43718,8 +40054,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ObjectTableCreateInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eObjectTableCreateInfoNVX; + const void* pNext = nullptr; + uint32_t objectCount; + const vk::ObjectEntryTypeNVX* pObjectEntryTypes; + const uint32_t* pObjectEntryCounts; + const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; + uint32_t maxUniformBuffersPerDescriptor; + uint32_t maxStorageBuffersPerDescriptor; + uint32_t maxStorageImagesPerDescriptor; + uint32_t maxSampledImagesPerDescriptor; + uint32_t maxPipelineLayouts; }; static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -43734,12 +40080,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43806,12 +40152,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43894,12 +40240,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43978,12 +40324,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44058,12 +40404,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44142,12 +40488,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44201,17 +40547,26 @@ namespace VULKAN_HPP_NAMESPACE struct PastPresentationTimingGOOGLE { - PastPresentationTimingGOOGLE() VULKAN_HPP_NOEXCEPT + PastPresentationTimingGOOGLE( uint32_t presentID_ = 0, + uint64_t desiredPresentTime_ = 0, + uint64_t actualPresentTime_ = 0, + uint64_t earliestPresentTime_ = 0, + uint64_t presentMargin_ = 0 ) VULKAN_HPP_NOEXCEPT + : presentID( presentID_ ) + , desiredPresentTime( desiredPresentTime_ ) + , actualPresentTime( actualPresentTime_ ) + , earliestPresentTime( earliestPresentTime_ ) + , presentMargin( presentMargin_ ) {} PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44249,47 +40604,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PerformanceConfigurationAcquireInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - {} - - PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; - const void* pNext = nullptr; - vk::PerformanceConfigurationTypeINTEL type; - }; - static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct PerformanceConfigurationAcquireInfoINTEL : public layout::PerformanceConfigurationAcquireInfoINTEL + struct PerformanceConfigurationAcquireInfoINTEL { VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceConfigurationAcquireInfoINTEL( type_ ) + : type( type_ ) {} + vk::PerformanceConfigurationAcquireInfoINTEL & operator=( vk::PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceConfigurationAcquireInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceConfigurationAcquireInfoINTEL( rhs ) - {} + { + *this = rhs; + } PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PerformanceConfigurationAcquireInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44327,53 +40661,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PerformanceConfigurationAcquireInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; + const void* pNext = nullptr; + vk::PerformanceConfigurationTypeINTEL type; }; static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PerformanceMarkerInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT - : marker( marker_ ) - {} - - PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL; - const void* pNext = nullptr; - uint64_t marker; - }; - static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct PerformanceMarkerInfoINTEL : public layout::PerformanceMarkerInfoINTEL + struct PerformanceMarkerInfoINTEL { VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceMarkerInfoINTEL( marker_ ) + : marker( marker_ ) {} + vk::PerformanceMarkerInfoINTEL & operator=( vk::PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceMarkerInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceMarkerInfoINTEL( rhs ) - {} + { + *this = rhs; + } PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PerformanceMarkerInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44411,61 +40726,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PerformanceMarkerInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL; + const void* pNext = nullptr; + uint64_t marker; }; static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PerformanceOverrideInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware, - vk::Bool32 enable_ = 0, - uint64_t parameter_ = 0 ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - , enable( enable_ ) - , parameter( parameter_ ) - {} - - PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL; - const void* pNext = nullptr; - vk::PerformanceOverrideTypeINTEL type; - vk::Bool32 enable; - uint64_t parameter; - }; - static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct PerformanceOverrideInfoINTEL : public layout::PerformanceOverrideInfoINTEL + struct PerformanceOverrideInfoINTEL { VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware, vk::Bool32 enable_ = 0, uint64_t parameter_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceOverrideInfoINTEL( type_, enable_, parameter_ ) + : type( type_ ) + , enable( enable_ ) + , parameter( parameter_ ) {} + vk::PerformanceOverrideInfoINTEL & operator=( vk::PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceOverrideInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceOverrideInfoINTEL( rhs ) - {} + { + *this = rhs; + } PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PerformanceOverrideInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44517,53 +40809,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PerformanceOverrideInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL; + const void* pNext = nullptr; + vk::PerformanceOverrideTypeINTEL type; + vk::Bool32 enable; + uint64_t parameter; }; static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PerformanceStreamMarkerInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT - : marker( marker_ ) - {} - - PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL; - const void* pNext = nullptr; - uint32_t marker; - }; - static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct PerformanceStreamMarkerInfoINTEL : public layout::PerformanceStreamMarkerInfoINTEL + struct PerformanceStreamMarkerInfoINTEL { VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceStreamMarkerInfoINTEL( marker_ ) + : marker( marker_ ) {} + vk::PerformanceStreamMarkerInfoINTEL & operator=( vk::PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceStreamMarkerInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceStreamMarkerInfoINTEL( rhs ) - {} + { + *this = rhs; + } PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PerformanceStreamMarkerInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44601,8 +40876,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PerformanceStreamMarkerInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL; + const void* pNext = nullptr; + uint32_t marker; }; static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -44693,12 +40970,12 @@ namespace VULKAN_HPP_NAMESPACE PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PerformanceValueINTEL& operator=( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44731,59 +41008,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDevice16BitStorageFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0, - vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0, - vk::Bool32 storagePushConstant16_ = 0, - vk::Bool32 storageInputOutput16_ = 0 ) VULKAN_HPP_NOEXCEPT - : storageBuffer16BitAccess( storageBuffer16BitAccess_ ) - , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) - , storagePushConstant16( storagePushConstant16_ ) - , storageInputOutput16( storageInputOutput16_ ) - {} - - PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; - void* pNext = nullptr; - vk::Bool32 storageBuffer16BitAccess; - vk::Bool32 uniformAndStorageBuffer16BitAccess; - vk::Bool32 storagePushConstant16; - vk::Bool32 storageInputOutput16; - }; - static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevice16BitStorageFeatures : public layout::PhysicalDevice16BitStorageFeatures + struct PhysicalDevice16BitStorageFeatures { VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0, vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0, vk::Bool32 storagePushConstant16_ = 0, vk::Bool32 storageInputOutput16_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevice16BitStorageFeatures( storageBuffer16BitAccess_, uniformAndStorageBuffer16BitAccess_, storagePushConstant16_, storageInputOutput16_ ) + : storageBuffer16BitAccess( storageBuffer16BitAccess_ ) + , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) + , storagePushConstant16( storagePushConstant16_ ) + , storageInputOutput16( storageInputOutput16_ ) {} + vk::PhysicalDevice16BitStorageFeatures & operator=( vk::PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevice16BitStorageFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevice16BitStorageFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevice16BitStorageFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44842,61 +41092,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevice16BitStorageFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; + void* pNext = nullptr; + vk::Bool32 storageBuffer16BitAccess; + vk::Bool32 uniformAndStorageBuffer16BitAccess; + vk::Bool32 storagePushConstant16; + vk::Bool32 storageInputOutput16; }; static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDevice8BitStorageFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0, - vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0, - vk::Bool32 storagePushConstant8_ = 0 ) VULKAN_HPP_NOEXCEPT - : storageBuffer8BitAccess( storageBuffer8BitAccess_ ) - , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ ) - , storagePushConstant8( storagePushConstant8_ ) - {} - - PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 storageBuffer8BitAccess; - vk::Bool32 uniformAndStorageBuffer8BitAccess; - vk::Bool32 storagePushConstant8; - }; - static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevice8BitStorageFeaturesKHR : public layout::PhysicalDevice8BitStorageFeaturesKHR + struct PhysicalDevice8BitStorageFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0, vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0, vk::Bool32 storagePushConstant8_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevice8BitStorageFeaturesKHR( storageBuffer8BitAccess_, uniformAndStorageBuffer8BitAccess_, storagePushConstant8_ ) + : storageBuffer8BitAccess( storageBuffer8BitAccess_ ) + , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ ) + , storagePushConstant8( storagePushConstant8_ ) {} + vk::PhysicalDevice8BitStorageFeaturesKHR & operator=( vk::PhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevice8BitStorageFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevice8BitStorageFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevice8BitStorageFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44948,53 +41178,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevice8BitStorageFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 storageBuffer8BitAccess; + vk::Bool32 uniformAndStorageBuffer8BitAccess; + vk::Bool32 storagePushConstant8; }; static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceASTCDecodeFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 ) VULKAN_HPP_NOEXCEPT - : decodeModeSharedExponent( decodeModeSharedExponent_ ) - {} - - PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 decodeModeSharedExponent; - }; - static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceASTCDecodeFeaturesEXT : public layout::PhysicalDeviceASTCDecodeFeaturesEXT + struct PhysicalDeviceASTCDecodeFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceASTCDecodeFeaturesEXT( decodeModeSharedExponent_ ) + : decodeModeSharedExponent( decodeModeSharedExponent_ ) {} + vk::PhysicalDeviceASTCDecodeFeaturesEXT & operator=( vk::PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceASTCDecodeFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceASTCDecodeFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceASTCDecodeFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45032,53 +41245,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceASTCDecodeFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 decodeModeSharedExponent; }; static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 ) VULKAN_HPP_NOEXCEPT - : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) - {} - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 advancedBlendCoherentOperations; - }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT : public layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( advancedBlendCoherentOperations_ ) + : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) {} + vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45116,57 +41310,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 advancedBlendCoherentOperations; }; static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT - { - protected: - PhysicalDeviceBlendOperationAdvancedPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; - void* pNext = nullptr; - uint32_t advancedBlendMaxColorAttachments; - vk::Bool32 advancedBlendIndependentBlend; - vk::Bool32 advancedBlendNonPremultipliedSrcColor; - vk::Bool32 advancedBlendNonPremultipliedDstColor; - vk::Bool32 advancedBlendCorrelatedOverlap; - vk::Bool32 advancedBlendAllOperations; - }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT : public layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT - { - PhysicalDeviceBlendOperationAdvancedPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT() + PhysicalDeviceBlendOperationAdvancedPropertiesEXT( uint32_t advancedBlendMaxColorAttachments_ = 0, + vk::Bool32 advancedBlendIndependentBlend_ = 0, + vk::Bool32 advancedBlendNonPremultipliedSrcColor_ = 0, + vk::Bool32 advancedBlendNonPremultipliedDstColor_ = 0, + vk::Bool32 advancedBlendCorrelatedOverlap_ = 0, + vk::Bool32 advancedBlendAllOperations_ = 0 ) VULKAN_HPP_NOEXCEPT + : advancedBlendMaxColorAttachments( advancedBlendMaxColorAttachments_ ) + , advancedBlendIndependentBlend( advancedBlendIndependentBlend_ ) + , advancedBlendNonPremultipliedSrcColor( advancedBlendNonPremultipliedSrcColor_ ) + , advancedBlendNonPremultipliedDstColor( advancedBlendNonPremultipliedDstColor_ ) + , advancedBlendCorrelatedOverlap( advancedBlendCorrelatedOverlap_ ) + , advancedBlendAllOperations( advancedBlendAllOperations_ ) {} + vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT & operator=( vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45197,61 +41378,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; + void* pNext = nullptr; + uint32_t advancedBlendMaxColorAttachments; + vk::Bool32 advancedBlendIndependentBlend; + vk::Bool32 advancedBlendNonPremultipliedSrcColor; + vk::Bool32 advancedBlendNonPremultipliedDstColor; + vk::Bool32 advancedBlendCorrelatedOverlap; + vk::Bool32 advancedBlendAllOperations; }; static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceBufferDeviceAddressFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0, - vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0, - vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 ) VULKAN_HPP_NOEXCEPT - : bufferDeviceAddress( bufferDeviceAddress_ ) - , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ) - , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ ) - {} - - PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 bufferDeviceAddress; - vk::Bool32 bufferDeviceAddressCaptureReplay; - vk::Bool32 bufferDeviceAddressMultiDevice; - }; - static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceBufferDeviceAddressFeaturesEXT : public layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT + struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0, vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0, vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( bufferDeviceAddress_, bufferDeviceAddressCaptureReplay_, bufferDeviceAddressMultiDevice_ ) + : bufferDeviceAddress( bufferDeviceAddress_ ) + , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ) + , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ ) {} + vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45303,53 +41466,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 bufferDeviceAddress; + vk::Bool32 bufferDeviceAddressCaptureReplay; + vk::Bool32 bufferDeviceAddressMultiDevice; }; static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceCoherentMemoryFeaturesAMD - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 ) VULKAN_HPP_NOEXCEPT - : deviceCoherentMemory( deviceCoherentMemory_ ) - {} - - PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; - void* pNext = nullptr; - vk::Bool32 deviceCoherentMemory; - }; - static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCoherentMemoryFeaturesAMD : public layout::PhysicalDeviceCoherentMemoryFeaturesAMD + struct PhysicalDeviceCoherentMemoryFeaturesAMD { VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( deviceCoherentMemory_ ) + : deviceCoherentMemory( deviceCoherentMemory_ ) {} + vk::PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( vk::PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCoherentMemoryFeaturesAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCoherentMemoryFeaturesAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45387,57 +41533,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCoherentMemoryFeaturesAMD::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; + void* pNext = nullptr; + vk::Bool32 deviceCoherentMemory; }; static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceComputeShaderDerivativesFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0, - vk::Bool32 computeDerivativeGroupLinear_ = 0 ) VULKAN_HPP_NOEXCEPT - : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ ) - , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ ) - {} - - PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV; - void* pNext = nullptr; - vk::Bool32 computeDerivativeGroupQuads; - vk::Bool32 computeDerivativeGroupLinear; - }; - static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceComputeShaderDerivativesFeaturesNV : public layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV + struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0, vk::Bool32 computeDerivativeGroupLinear_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( computeDerivativeGroupQuads_, computeDerivativeGroupLinear_ ) + : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ ) + , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ ) {} + vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV & operator=( vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45482,57 +41607,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV; + void* pNext = nullptr; + vk::Bool32 computeDerivativeGroupQuads; + vk::Bool32 computeDerivativeGroupLinear; }; static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceConditionalRenderingFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0, - vk::Bool32 inheritedConditionalRendering_ = 0 ) VULKAN_HPP_NOEXCEPT - : conditionalRendering( conditionalRendering_ ) - , inheritedConditionalRendering( inheritedConditionalRendering_ ) - {} - - PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 conditionalRendering; - vk::Bool32 inheritedConditionalRendering; - }; - static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceConditionalRenderingFeaturesEXT : public layout::PhysicalDeviceConditionalRenderingFeaturesEXT + struct PhysicalDeviceConditionalRenderingFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0, vk::Bool32 inheritedConditionalRendering_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( conditionalRendering_, inheritedConditionalRendering_ ) + : conditionalRendering( conditionalRendering_ ) + , inheritedConditionalRendering( inheritedConditionalRendering_ ) {} + vk::PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( vk::PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceConditionalRenderingFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceConditionalRenderingFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45577,60 +41682,51 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceConditionalRenderingFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 conditionalRendering; + vk::Bool32 inheritedConditionalRendering; }; static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceConservativeRasterizationPropertiesEXT { - struct PhysicalDeviceConservativeRasterizationPropertiesEXT - { - protected: - PhysicalDeviceConservativeRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; - void* pNext = nullptr; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - vk::Bool32 primitiveUnderestimation; - vk::Bool32 conservativePointAndLineRasterization; - vk::Bool32 degenerateTrianglesRasterized; - vk::Bool32 degenerateLinesRasterized; - vk::Bool32 fullyCoveredFragmentShaderInputVariable; - vk::Bool32 conservativeRasterizationPostDepthCoverage; - }; - static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceConservativeRasterizationPropertiesEXT : public layout::PhysicalDeviceConservativeRasterizationPropertiesEXT - { - PhysicalDeviceConservativeRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceConservativeRasterizationPropertiesEXT() + PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = 0, + float maxExtraPrimitiveOverestimationSize_ = 0, + float extraPrimitiveOverestimationSizeGranularity_ = 0, + vk::Bool32 primitiveUnderestimation_ = 0, + vk::Bool32 conservativePointAndLineRasterization_ = 0, + vk::Bool32 degenerateTrianglesRasterized_ = 0, + vk::Bool32 degenerateLinesRasterized_ = 0, + vk::Bool32 fullyCoveredFragmentShaderInputVariable_ = 0, + vk::Bool32 conservativeRasterizationPostDepthCoverage_ = 0 ) VULKAN_HPP_NOEXCEPT + : primitiveOverestimationSize( primitiveOverestimationSize_ ) + , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ ) + , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ ) + , primitiveUnderestimation( primitiveUnderestimation_ ) + , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ ) + , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ ) + , degenerateLinesRasterized( degenerateLinesRasterized_ ) + , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ ) + , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ ) {} + vk::PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=( vk::PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceConservativeRasterizationPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceConservativeRasterizationPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45664,57 +41760,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; + void* pNext = nullptr; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + vk::Bool32 primitiveUnderestimation; + vk::Bool32 conservativePointAndLineRasterization; + vk::Bool32 degenerateTrianglesRasterized; + vk::Bool32 degenerateLinesRasterized; + vk::Bool32 fullyCoveredFragmentShaderInputVariable; + vk::Bool32 conservativeRasterizationPostDepthCoverage; }; static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceCooperativeMatrixFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0, - vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 ) VULKAN_HPP_NOEXCEPT - : cooperativeMatrix( cooperativeMatrix_ ) - , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ ) - {} - - PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; - void* pNext = nullptr; - vk::Bool32 cooperativeMatrix; - vk::Bool32 cooperativeMatrixRobustBufferAccess; - }; - static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCooperativeMatrixFeaturesNV : public layout::PhysicalDeviceCooperativeMatrixFeaturesNV + struct PhysicalDeviceCooperativeMatrixFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0, vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( cooperativeMatrix_, cooperativeMatrixRobustBufferAccess_ ) + : cooperativeMatrix( cooperativeMatrix_ ) + , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ ) {} + vk::PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( vk::PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCooperativeMatrixFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCooperativeMatrixFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45759,52 +41842,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCooperativeMatrixFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; + void* pNext = nullptr; + vk::Bool32 cooperativeMatrix; + vk::Bool32 cooperativeMatrixRobustBufferAccess; }; static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceCooperativeMatrixPropertiesNV { - struct PhysicalDeviceCooperativeMatrixPropertiesNV - { - protected: - PhysicalDeviceCooperativeMatrixPropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; - void* pNext = nullptr; - vk::ShaderStageFlags cooperativeMatrixSupportedStages; - }; - static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCooperativeMatrixPropertiesNV : public layout::PhysicalDeviceCooperativeMatrixPropertiesNV - { - PhysicalDeviceCooperativeMatrixPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCooperativeMatrixPropertiesNV() + PhysicalDeviceCooperativeMatrixPropertiesNV( vk::ShaderStageFlags cooperativeMatrixSupportedStages_ = vk::ShaderStageFlags() ) VULKAN_HPP_NOEXCEPT + : cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ ) {} + vk::PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( vk::PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCooperativeMatrixPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCooperativeMatrixPropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCooperativeMatrixPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45830,53 +41896,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCooperativeMatrixPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; + void* pNext = nullptr; + vk::ShaderStageFlags cooperativeMatrixSupportedStages; }; static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceCornerSampledImageFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 ) VULKAN_HPP_NOEXCEPT - : cornerSampledImage( cornerSampledImage_ ) - {} - - PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; - void* pNext = nullptr; - vk::Bool32 cornerSampledImage; - }; - static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCornerSampledImageFeaturesNV : public layout::PhysicalDeviceCornerSampledImageFeaturesNV + struct PhysicalDeviceCornerSampledImageFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCornerSampledImageFeaturesNV( cornerSampledImage_ ) + : cornerSampledImage( cornerSampledImage_ ) {} + vk::PhysicalDeviceCornerSampledImageFeaturesNV & operator=( vk::PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCornerSampledImageFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCornerSampledImageFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCornerSampledImageFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45914,53 +41961,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCornerSampledImageFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; + void* pNext = nullptr; + vk::Bool32 cornerSampledImage; }; static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceCoverageReductionModeFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 ) VULKAN_HPP_NOEXCEPT - : coverageReductionMode( coverageReductionMode_ ) - {} - - PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; - void* pNext = nullptr; - vk::Bool32 coverageReductionMode; - }; - static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCoverageReductionModeFeaturesNV : public layout::PhysicalDeviceCoverageReductionModeFeaturesNV + struct PhysicalDeviceCoverageReductionModeFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( coverageReductionMode_ ) + : coverageReductionMode( coverageReductionMode_ ) {} + vk::PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( vk::PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCoverageReductionModeFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCoverageReductionModeFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45998,53 +42026,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCoverageReductionModeFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; + void* pNext = nullptr; + vk::Bool32 coverageReductionMode; }; static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 ) VULKAN_HPP_NOEXCEPT - : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ ) - {} - - PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - void* pNext = nullptr; - vk::Bool32 dedicatedAllocationImageAliasing; - }; - static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : public layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( dedicatedAllocationImageAliasing_ ) + : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ ) {} + vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & operator=( vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46082,53 +42091,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + void* pNext = nullptr; + vk::Bool32 dedicatedAllocationImageAliasing; }; static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceDepthClipEnableFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : depthClipEnable( depthClipEnable_ ) - {} - - PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 depthClipEnable; - }; - static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDepthClipEnableFeaturesEXT : public layout::PhysicalDeviceDepthClipEnableFeaturesEXT + struct PhysicalDeviceDepthClipEnableFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( depthClipEnable_ ) + : depthClipEnable( depthClipEnable_ ) {} + vk::PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( vk::PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDepthClipEnableFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDepthClipEnableFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46166,55 +42156,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDepthClipEnableFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 depthClipEnable; }; static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceDepthStencilResolvePropertiesKHR { - struct PhysicalDeviceDepthStencilResolvePropertiesKHR - { - protected: - PhysicalDeviceDepthStencilResolvePropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR; - void* pNext = nullptr; - vk::ResolveModeFlagsKHR supportedDepthResolveModes; - vk::ResolveModeFlagsKHR supportedStencilResolveModes; - vk::Bool32 independentResolveNone; - vk::Bool32 independentResolve; - }; - static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDepthStencilResolvePropertiesKHR : public layout::PhysicalDeviceDepthStencilResolvePropertiesKHR - { - PhysicalDeviceDepthStencilResolvePropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDepthStencilResolvePropertiesKHR() + PhysicalDeviceDepthStencilResolvePropertiesKHR( vk::ResolveModeFlagsKHR supportedDepthResolveModes_ = vk::ResolveModeFlagsKHR(), + vk::ResolveModeFlagsKHR supportedStencilResolveModes_ = vk::ResolveModeFlagsKHR(), + vk::Bool32 independentResolveNone_ = 0, + vk::Bool32 independentResolve_ = 0 ) VULKAN_HPP_NOEXCEPT + : supportedDepthResolveModes( supportedDepthResolveModes_ ) + , supportedStencilResolveModes( supportedStencilResolveModes_ ) + , independentResolveNone( independentResolveNone_ ) + , independentResolve( independentResolve_ ) {} + vk::PhysicalDeviceDepthStencilResolvePropertiesKHR & operator=( vk::PhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDepthStencilResolvePropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDepthStencilResolvePropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46243,98 +42218,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR; + void* pNext = nullptr; + vk::ResolveModeFlagsKHR supportedDepthResolveModes; + vk::ResolveModeFlagsKHR supportedStencilResolveModes; + vk::Bool32 independentResolveNone; + vk::Bool32 independentResolve; }; static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceDescriptorIndexingFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0, - vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0, - vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0, - vk::Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0, - vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0, - vk::Bool32 descriptorBindingPartiallyBound_ = 0, - vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0, - vk::Bool32 runtimeDescriptorArray_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ ) - , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ ) - , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ ) - , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ ) - , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ ) - , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ ) - , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ ) - , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ ) - , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ ) - , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ ) - , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ ) - , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ ) - , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ ) - , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ ) - , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ ) - , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ ) - , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ ) - , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ ) - , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ ) - , runtimeDescriptorArray( runtimeDescriptorArray_ ) - {} - - PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 shaderInputAttachmentArrayDynamicIndexing; - vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing; - vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing; - vk::Bool32 shaderUniformBufferArrayNonUniformIndexing; - vk::Bool32 shaderSampledImageArrayNonUniformIndexing; - vk::Bool32 shaderStorageBufferArrayNonUniformIndexing; - vk::Bool32 shaderStorageImageArrayNonUniformIndexing; - vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing; - vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing; - vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing; - vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind; - vk::Bool32 descriptorBindingSampledImageUpdateAfterBind; - vk::Bool32 descriptorBindingStorageImageUpdateAfterBind; - vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind; - vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - vk::Bool32 descriptorBindingUpdateUnusedWhilePending; - vk::Bool32 descriptorBindingPartiallyBound; - vk::Bool32 descriptorBindingVariableDescriptorCount; - vk::Bool32 runtimeDescriptorArray; - }; - static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDescriptorIndexingFeaturesEXT : public layout::PhysicalDeviceDescriptorIndexingFeaturesEXT + struct PhysicalDeviceDescriptorIndexingFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0, vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0, @@ -46356,16 +42251,42 @@ namespace VULKAN_HPP_NAMESPACE vk::Bool32 descriptorBindingPartiallyBound_ = 0, vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0, vk::Bool32 runtimeDescriptorArray_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( shaderInputAttachmentArrayDynamicIndexing_, shaderUniformTexelBufferArrayDynamicIndexing_, shaderStorageTexelBufferArrayDynamicIndexing_, shaderUniformBufferArrayNonUniformIndexing_, shaderSampledImageArrayNonUniformIndexing_, shaderStorageBufferArrayNonUniformIndexing_, shaderStorageImageArrayNonUniformIndexing_, shaderInputAttachmentArrayNonUniformIndexing_, shaderUniformTexelBufferArrayNonUniformIndexing_, shaderStorageTexelBufferArrayNonUniformIndexing_, descriptorBindingUniformBufferUpdateAfterBind_, descriptorBindingSampledImageUpdateAfterBind_, descriptorBindingStorageImageUpdateAfterBind_, descriptorBindingStorageBufferUpdateAfterBind_, descriptorBindingUniformTexelBufferUpdateAfterBind_, descriptorBindingStorageTexelBufferUpdateAfterBind_, descriptorBindingUpdateUnusedWhilePending_, descriptorBindingPartiallyBound_, descriptorBindingVariableDescriptorCount_, runtimeDescriptorArray_ ) + : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ ) + , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ ) + , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ ) + , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ ) + , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ ) + , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ ) + , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ ) + , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ ) + , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ ) + , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ ) + , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ ) + , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ ) + , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ ) + , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ ) + , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ ) + , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ ) + , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ ) + , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ ) + , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ ) + , runtimeDescriptorArray( runtimeDescriptorArray_ ) {} + vk::PhysicalDeviceDescriptorIndexingFeaturesEXT & operator=( vk::PhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDescriptorIndexingFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46536,74 +42457,97 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 shaderInputAttachmentArrayDynamicIndexing; + vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing; + vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing; + vk::Bool32 shaderUniformBufferArrayNonUniformIndexing; + vk::Bool32 shaderSampledImageArrayNonUniformIndexing; + vk::Bool32 shaderStorageBufferArrayNonUniformIndexing; + vk::Bool32 shaderStorageImageArrayNonUniformIndexing; + vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing; + vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing; + vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing; + vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind; + vk::Bool32 descriptorBindingSampledImageUpdateAfterBind; + vk::Bool32 descriptorBindingStorageImageUpdateAfterBind; + vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind; + vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + vk::Bool32 descriptorBindingUpdateUnusedWhilePending; + vk::Bool32 descriptorBindingPartiallyBound; + vk::Bool32 descriptorBindingVariableDescriptorCount; + vk::Bool32 runtimeDescriptorArray; }; static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceDescriptorIndexingPropertiesEXT { - struct PhysicalDeviceDescriptorIndexingPropertiesEXT - { - protected: - PhysicalDeviceDescriptorIndexingPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT; - void* pNext = nullptr; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative; - vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative; - vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative; - vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative; - vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative; - vk::Bool32 robustBufferAccessUpdateAfterBind; - vk::Bool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; - }; - static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDescriptorIndexingPropertiesEXT : public layout::PhysicalDeviceDescriptorIndexingPropertiesEXT - { - PhysicalDeviceDescriptorIndexingPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDescriptorIndexingPropertiesEXT() + PhysicalDeviceDescriptorIndexingPropertiesEXT( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = 0, + vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = 0, + vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = 0, + vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ = 0, + vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative_ = 0, + vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ = 0, + vk::Bool32 robustBufferAccessUpdateAfterBind_ = 0, + vk::Bool32 quadDivergentImplicitLod_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ = 0, + uint32_t maxPerStageUpdateAfterBindResources_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindSamplers_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxUpdateAfterBindDescriptorsInAllPools( maxUpdateAfterBindDescriptorsInAllPools_ ) + , shaderUniformBufferArrayNonUniformIndexingNative( shaderUniformBufferArrayNonUniformIndexingNative_ ) + , shaderSampledImageArrayNonUniformIndexingNative( shaderSampledImageArrayNonUniformIndexingNative_ ) + , shaderStorageBufferArrayNonUniformIndexingNative( shaderStorageBufferArrayNonUniformIndexingNative_ ) + , shaderStorageImageArrayNonUniformIndexingNative( shaderStorageImageArrayNonUniformIndexingNative_ ) + , shaderInputAttachmentArrayNonUniformIndexingNative( shaderInputAttachmentArrayNonUniformIndexingNative_ ) + , robustBufferAccessUpdateAfterBind( robustBufferAccessUpdateAfterBind_ ) + , quadDivergentImplicitLod( quadDivergentImplicitLod_ ) + , maxPerStageDescriptorUpdateAfterBindSamplers( maxPerStageDescriptorUpdateAfterBindSamplers_ ) + , maxPerStageDescriptorUpdateAfterBindUniformBuffers( maxPerStageDescriptorUpdateAfterBindUniformBuffers_ ) + , maxPerStageDescriptorUpdateAfterBindStorageBuffers( maxPerStageDescriptorUpdateAfterBindStorageBuffers_ ) + , maxPerStageDescriptorUpdateAfterBindSampledImages( maxPerStageDescriptorUpdateAfterBindSampledImages_ ) + , maxPerStageDescriptorUpdateAfterBindStorageImages( maxPerStageDescriptorUpdateAfterBindStorageImages_ ) + , maxPerStageDescriptorUpdateAfterBindInputAttachments( maxPerStageDescriptorUpdateAfterBindInputAttachments_ ) + , maxPerStageUpdateAfterBindResources( maxPerStageUpdateAfterBindResources_ ) + , maxDescriptorSetUpdateAfterBindSamplers( maxDescriptorSetUpdateAfterBindSamplers_ ) + , maxDescriptorSetUpdateAfterBindUniformBuffers( maxDescriptorSetUpdateAfterBindUniformBuffers_ ) + , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ ) + , maxDescriptorSetUpdateAfterBindStorageBuffers( maxDescriptorSetUpdateAfterBindStorageBuffers_ ) + , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ ) + , maxDescriptorSetUpdateAfterBindSampledImages( maxDescriptorSetUpdateAfterBindSampledImages_ ) + , maxDescriptorSetUpdateAfterBindStorageImages( maxDescriptorSetUpdateAfterBindStorageImages_ ) + , maxDescriptorSetUpdateAfterBindInputAttachments( maxDescriptorSetUpdateAfterBindInputAttachments_ ) {} + vk::PhysicalDeviceDescriptorIndexingPropertiesEXT & operator=( vk::PhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDescriptorIndexingPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDescriptorIndexingPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46651,52 +42595,56 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT; + void* pNext = nullptr; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative; + vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative; + vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative; + vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative; + vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative; + vk::Bool32 robustBufferAccessUpdateAfterBind; + vk::Bool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; }; static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceDiscardRectanglePropertiesEXT { - struct PhysicalDeviceDiscardRectanglePropertiesEXT - { - protected: - PhysicalDeviceDiscardRectanglePropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; - void* pNext = nullptr; - uint32_t maxDiscardRectangles; - }; - static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDiscardRectanglePropertiesEXT : public layout::PhysicalDeviceDiscardRectanglePropertiesEXT - { - PhysicalDeviceDiscardRectanglePropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDiscardRectanglePropertiesEXT() + PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxDiscardRectangles( maxDiscardRectangles_ ) {} + vk::PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( vk::PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDiscardRectanglePropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDiscardRectanglePropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDiscardRectanglePropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46722,55 +42670,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDiscardRectanglePropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; + void* pNext = nullptr; + uint32_t maxDiscardRectangles; }; static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceDriverPropertiesKHR { - struct PhysicalDeviceDriverPropertiesKHR + PhysicalDeviceDriverPropertiesKHR( vk::DriverIdKHR driverID_ = vk::DriverIdKHR::eAmdProprietary, + std::array const& driverName_ = { { 0 } }, + std::array const& driverInfo_ = { { 0 } }, + vk::ConformanceVersionKHR conformanceVersion_ = vk::ConformanceVersionKHR() ) VULKAN_HPP_NOEXCEPT + : driverID( driverID_ ) + , driverName{} + , driverInfo{} + , conformanceVersion( conformanceVersion_ ) { - protected: - PhysicalDeviceDriverPropertiesKHR() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( driverName, driverName_ ); + vk::ConstExpressionArrayCopy::copy( driverInfo, driverInfo_ ); + } - PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR; - void* pNext = nullptr; - vk::DriverIdKHR driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; - vk::ConformanceVersionKHR conformanceVersion; - }; - static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDriverPropertiesKHR : public layout::PhysicalDeviceDriverPropertiesKHR - { - PhysicalDeviceDriverPropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDriverPropertiesKHR() - {} + vk::PhysicalDeviceDriverPropertiesKHR & operator=( vk::PhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDriverPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDriverPropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDriverPropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46799,53 +42735,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDriverPropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR; + void* pNext = nullptr; + vk::DriverIdKHR driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; + vk::ConformanceVersionKHR conformanceVersion; }; static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExclusiveScissorFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 ) VULKAN_HPP_NOEXCEPT - : exclusiveScissor( exclusiveScissor_ ) - {} - - PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; - void* pNext = nullptr; - vk::Bool32 exclusiveScissor; - }; - static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExclusiveScissorFeaturesNV : public layout::PhysicalDeviceExclusiveScissorFeaturesNV + struct PhysicalDeviceExclusiveScissorFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExclusiveScissorFeaturesNV( exclusiveScissor_ ) + : exclusiveScissor( exclusiveScissor_ ) {} + vk::PhysicalDeviceExclusiveScissorFeaturesNV & operator=( vk::PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExclusiveScissorFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExclusiveScissorFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExclusiveScissorFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46883,61 +42803,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExclusiveScissorFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; + void* pNext = nullptr; + vk::Bool32 exclusiveScissor; }; static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExternalBufferInfo - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(), - vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(), - vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , usage( usage_ ) - , handleType( handleType_ ) - {} - - PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; - const void* pNext = nullptr; - vk::BufferCreateFlags flags; - vk::BufferUsageFlags usage; - vk::ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalBufferInfo : public layout::PhysicalDeviceExternalBufferInfo + struct PhysicalDeviceExternalBufferInfo { VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(), vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(), vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalBufferInfo( flags_, usage_, handleType_ ) + : flags( flags_ ) + , usage( usage_ ) + , handleType( handleType_ ) {} + vk::PhysicalDeviceExternalBufferInfo & operator=( vk::PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalBufferInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalBufferInfo( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalBufferInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46989,53 +42886,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalBufferInfo::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; + const void* pNext = nullptr; + vk::BufferCreateFlags flags; + vk::BufferUsageFlags usage; + vk::ExternalMemoryHandleTypeFlagBits handleType; }; static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExternalFenceInfo - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - {} - - PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; - const void* pNext = nullptr; - vk::ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalFenceInfo : public layout::PhysicalDeviceExternalFenceInfo + struct PhysicalDeviceExternalFenceInfo { VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalFenceInfo( handleType_ ) + : handleType( handleType_ ) {} + vk::PhysicalDeviceExternalFenceInfo & operator=( vk::PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalFenceInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalFenceInfo( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalFenceInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47073,53 +42953,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalFenceInfo::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; + const void* pNext = nullptr; + vk::ExternalFenceHandleTypeFlagBits handleType; }; static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExternalImageFormatInfo - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - {} - - PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalImageFormatInfo : public layout::PhysicalDeviceExternalImageFormatInfo + struct PhysicalDeviceExternalImageFormatInfo { VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalImageFormatInfo( handleType_ ) + : handleType( handleType_ ) {} + vk::PhysicalDeviceExternalImageFormatInfo & operator=( vk::PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalImageFormatInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalImageFormatInfo( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalImageFormatInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47157,52 +43018,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalImageFormatInfo::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagBits handleType; }; static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceExternalMemoryHostPropertiesEXT { - struct PhysicalDeviceExternalMemoryHostPropertiesEXT - { - protected: - PhysicalDeviceExternalMemoryHostPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; - void* pNext = nullptr; - vk::DeviceSize minImportedHostPointerAlignment; - }; - static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalMemoryHostPropertiesEXT : public layout::PhysicalDeviceExternalMemoryHostPropertiesEXT - { - PhysicalDeviceExternalMemoryHostPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalMemoryHostPropertiesEXT() + PhysicalDeviceExternalMemoryHostPropertiesEXT( vk::DeviceSize minImportedHostPointerAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT + : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) {} + vk::PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( vk::PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalMemoryHostPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalMemoryHostPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47228,53 +43071,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; + void* pNext = nullptr; + vk::DeviceSize minImportedHostPointerAlignment; }; static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExternalSemaphoreInfo - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - {} - - PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; - const void* pNext = nullptr; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalSemaphoreInfo : public layout::PhysicalDeviceExternalSemaphoreInfo + struct PhysicalDeviceExternalSemaphoreInfo { VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalSemaphoreInfo( handleType_ ) + : handleType( handleType_ ) {} + vk::PhysicalDeviceExternalSemaphoreInfo & operator=( vk::PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalSemaphoreInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalSemaphoreInfo( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalSemaphoreInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47312,53 +43136,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalSemaphoreInfo::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; + const void* pNext = nullptr; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; }; static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceFeatures2 - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() ) VULKAN_HPP_NOEXCEPT - : features( features_ ) - {} - - PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFeatures2; - void* pNext = nullptr; - vk::PhysicalDeviceFeatures features; - }; - static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFeatures2 : public layout::PhysicalDeviceFeatures2 + struct PhysicalDeviceFeatures2 { VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFeatures2( features_ ) + : features( features_ ) {} + vk::PhysicalDeviceFeatures2 & operator=( vk::PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFeatures2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFeatures2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFeatures2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47396,68 +43201,66 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFeatures2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFeatures2; + void* pNext = nullptr; + vk::PhysicalDeviceFeatures features; }; static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceFloatControlsPropertiesKHR { - struct PhysicalDeviceFloatControlsPropertiesKHR - { - protected: - PhysicalDeviceFloatControlsPropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR; - void* pNext = nullptr; - vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence; - vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence; - vk::Bool32 shaderSignedZeroInfNanPreserveFloat16; - vk::Bool32 shaderSignedZeroInfNanPreserveFloat32; - vk::Bool32 shaderSignedZeroInfNanPreserveFloat64; - vk::Bool32 shaderDenormPreserveFloat16; - vk::Bool32 shaderDenormPreserveFloat32; - vk::Bool32 shaderDenormPreserveFloat64; - vk::Bool32 shaderDenormFlushToZeroFloat16; - vk::Bool32 shaderDenormFlushToZeroFloat32; - vk::Bool32 shaderDenormFlushToZeroFloat64; - vk::Bool32 shaderRoundingModeRTEFloat16; - vk::Bool32 shaderRoundingModeRTEFloat32; - vk::Bool32 shaderRoundingModeRTEFloat64; - vk::Bool32 shaderRoundingModeRTZFloat16; - vk::Bool32 shaderRoundingModeRTZFloat32; - vk::Bool32 shaderRoundingModeRTZFloat64; - }; - static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFloatControlsPropertiesKHR : public layout::PhysicalDeviceFloatControlsPropertiesKHR - { - PhysicalDeviceFloatControlsPropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFloatControlsPropertiesKHR() + PhysicalDeviceFloatControlsPropertiesKHR( vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence_ = vk::ShaderFloatControlsIndependenceKHR::e32BitOnly, + vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence_ = vk::ShaderFloatControlsIndependenceKHR::e32BitOnly, + vk::Bool32 shaderSignedZeroInfNanPreserveFloat16_ = 0, + vk::Bool32 shaderSignedZeroInfNanPreserveFloat32_ = 0, + vk::Bool32 shaderSignedZeroInfNanPreserveFloat64_ = 0, + vk::Bool32 shaderDenormPreserveFloat16_ = 0, + vk::Bool32 shaderDenormPreserveFloat32_ = 0, + vk::Bool32 shaderDenormPreserveFloat64_ = 0, + vk::Bool32 shaderDenormFlushToZeroFloat16_ = 0, + vk::Bool32 shaderDenormFlushToZeroFloat32_ = 0, + vk::Bool32 shaderDenormFlushToZeroFloat64_ = 0, + vk::Bool32 shaderRoundingModeRTEFloat16_ = 0, + vk::Bool32 shaderRoundingModeRTEFloat32_ = 0, + vk::Bool32 shaderRoundingModeRTEFloat64_ = 0, + vk::Bool32 shaderRoundingModeRTZFloat16_ = 0, + vk::Bool32 shaderRoundingModeRTZFloat32_ = 0, + vk::Bool32 shaderRoundingModeRTZFloat64_ = 0 ) VULKAN_HPP_NOEXCEPT + : denormBehaviorIndependence( denormBehaviorIndependence_ ) + , roundingModeIndependence( roundingModeIndependence_ ) + , shaderSignedZeroInfNanPreserveFloat16( shaderSignedZeroInfNanPreserveFloat16_ ) + , shaderSignedZeroInfNanPreserveFloat32( shaderSignedZeroInfNanPreserveFloat32_ ) + , shaderSignedZeroInfNanPreserveFloat64( shaderSignedZeroInfNanPreserveFloat64_ ) + , shaderDenormPreserveFloat16( shaderDenormPreserveFloat16_ ) + , shaderDenormPreserveFloat32( shaderDenormPreserveFloat32_ ) + , shaderDenormPreserveFloat64( shaderDenormPreserveFloat64_ ) + , shaderDenormFlushToZeroFloat16( shaderDenormFlushToZeroFloat16_ ) + , shaderDenormFlushToZeroFloat32( shaderDenormFlushToZeroFloat32_ ) + , shaderDenormFlushToZeroFloat64( shaderDenormFlushToZeroFloat64_ ) + , shaderRoundingModeRTEFloat16( shaderRoundingModeRTEFloat16_ ) + , shaderRoundingModeRTEFloat32( shaderRoundingModeRTEFloat32_ ) + , shaderRoundingModeRTEFloat64( shaderRoundingModeRTEFloat64_ ) + , shaderRoundingModeRTZFloat16( shaderRoundingModeRTZFloat16_ ) + , shaderRoundingModeRTZFloat32( shaderRoundingModeRTZFloat32_ ) + , shaderRoundingModeRTZFloat64( shaderRoundingModeRTZFloat64_ ) {} + vk::PhysicalDeviceFloatControlsPropertiesKHR & operator=( vk::PhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFloatControlsPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFloatControlsPropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFloatControlsPropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47499,54 +43302,54 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFloatControlsPropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR; + void* pNext = nullptr; + vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence; + vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence; + vk::Bool32 shaderSignedZeroInfNanPreserveFloat16; + vk::Bool32 shaderSignedZeroInfNanPreserveFloat32; + vk::Bool32 shaderSignedZeroInfNanPreserveFloat64; + vk::Bool32 shaderDenormPreserveFloat16; + vk::Bool32 shaderDenormPreserveFloat32; + vk::Bool32 shaderDenormPreserveFloat64; + vk::Bool32 shaderDenormFlushToZeroFloat16; + vk::Bool32 shaderDenormFlushToZeroFloat32; + vk::Bool32 shaderDenormFlushToZeroFloat64; + vk::Bool32 shaderRoundingModeRTEFloat16; + vk::Bool32 shaderRoundingModeRTEFloat32; + vk::Bool32 shaderRoundingModeRTEFloat64; + vk::Bool32 shaderRoundingModeRTZFloat16; + vk::Bool32 shaderRoundingModeRTZFloat32; + vk::Bool32 shaderRoundingModeRTZFloat64; }; static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceFragmentDensityMapFeaturesEXT { - struct PhysicalDeviceFragmentDensityMapFeaturesEXT - { - protected: - PhysicalDeviceFragmentDensityMapFeaturesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 fragmentDensityMap; - vk::Bool32 fragmentDensityMapDynamic; - vk::Bool32 fragmentDensityMapNonSubsampledImages; - }; - static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFragmentDensityMapFeaturesEXT : public layout::PhysicalDeviceFragmentDensityMapFeaturesEXT - { - PhysicalDeviceFragmentDensityMapFeaturesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentDensityMapFeaturesEXT() + PhysicalDeviceFragmentDensityMapFeaturesEXT( vk::Bool32 fragmentDensityMap_ = 0, + vk::Bool32 fragmentDensityMapDynamic_ = 0, + vk::Bool32 fragmentDensityMapNonSubsampledImages_ = 0 ) VULKAN_HPP_NOEXCEPT + : fragmentDensityMap( fragmentDensityMap_ ) + , fragmentDensityMapDynamic( fragmentDensityMapDynamic_ ) + , fragmentDensityMapNonSubsampledImages( fragmentDensityMapNonSubsampledImages_ ) {} + vk::PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( vk::PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentDensityMapFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentDensityMapFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47574,54 +43377,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 fragmentDensityMap; + vk::Bool32 fragmentDensityMapDynamic; + vk::Bool32 fragmentDensityMapNonSubsampledImages; }; static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceFragmentDensityMapPropertiesEXT { - struct PhysicalDeviceFragmentDensityMapPropertiesEXT - { - protected: - PhysicalDeviceFragmentDensityMapPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; - void* pNext = nullptr; - vk::Extent2D minFragmentDensityTexelSize; - vk::Extent2D maxFragmentDensityTexelSize; - vk::Bool32 fragmentDensityInvocations; - }; - static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFragmentDensityMapPropertiesEXT : public layout::PhysicalDeviceFragmentDensityMapPropertiesEXT - { - PhysicalDeviceFragmentDensityMapPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentDensityMapPropertiesEXT() + PhysicalDeviceFragmentDensityMapPropertiesEXT( vk::Extent2D minFragmentDensityTexelSize_ = vk::Extent2D(), + vk::Extent2D maxFragmentDensityTexelSize_ = vk::Extent2D(), + vk::Bool32 fragmentDensityInvocations_ = 0 ) VULKAN_HPP_NOEXCEPT + : minFragmentDensityTexelSize( minFragmentDensityTexelSize_ ) + , maxFragmentDensityTexelSize( maxFragmentDensityTexelSize_ ) + , fragmentDensityInvocations( fragmentDensityInvocations_ ) {} + vk::PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( vk::PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentDensityMapPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentDensityMapPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47649,53 +43438,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; + void* pNext = nullptr; + vk::Extent2D minFragmentDensityTexelSize; + vk::Extent2D maxFragmentDensityTexelSize; + vk::Bool32 fragmentDensityInvocations; }; static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 ) VULKAN_HPP_NOEXCEPT - : fragmentShaderBarycentric( fragmentShaderBarycentric_ ) - {} - - PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV; - void* pNext = nullptr; - vk::Bool32 fragmentShaderBarycentric; - }; - static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV : public layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV + struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( fragmentShaderBarycentric_ ) + : fragmentShaderBarycentric( fragmentShaderBarycentric_ ) {} + vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV & operator=( vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47733,61 +43505,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV; + void* pNext = nullptr; + vk::Bool32 fragmentShaderBarycentric; }; static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0, - vk::Bool32 fragmentShaderPixelInterlock_ = 0, - vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 ) VULKAN_HPP_NOEXCEPT - : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ ) - , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ ) - , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ ) - {} - - PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 fragmentShaderSampleInterlock; - vk::Bool32 fragmentShaderPixelInterlock; - vk::Bool32 fragmentShaderShadingRateInterlock; - }; - static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT : public layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT + struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0, vk::Bool32 fragmentShaderPixelInterlock_ = 0, vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( fragmentShaderSampleInterlock_, fragmentShaderPixelInterlock_, fragmentShaderShadingRateInterlock_ ) + : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ ) + , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ ) + , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ ) {} + vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47839,54 +43588,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 fragmentShaderSampleInterlock; + vk::Bool32 fragmentShaderPixelInterlock; + vk::Bool32 fragmentShaderShadingRateInterlock; }; static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceGroupProperties { - struct PhysicalDeviceGroupProperties + PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = 0, + std::array const& physicalDevices_ = { { vk::PhysicalDevice() } }, + vk::Bool32 subsetAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT + : physicalDeviceCount( physicalDeviceCount_ ) + , physicalDevices{} + , subsetAllocation( subsetAllocation_ ) { - protected: - PhysicalDeviceGroupProperties() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( physicalDevices, physicalDevices_ ); + } - PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceGroupProperties; - void* pNext = nullptr; - uint32_t physicalDeviceCount; - vk::PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; - vk::Bool32 subsetAllocation; - }; - static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceGroupProperties : public layout::PhysicalDeviceGroupProperties - { - PhysicalDeviceGroupProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceGroupProperties() - {} + vk::PhysicalDeviceGroupProperties & operator=( vk::PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceGroupProperties ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceGroupProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceGroupProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47914,53 +43651,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceGroupProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceGroupProperties; + void* pNext = nullptr; + uint32_t physicalDeviceCount; + vk::PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + vk::Bool32 subsetAllocation; }; static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceHostQueryResetFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 ) VULKAN_HPP_NOEXCEPT - : hostQueryReset( hostQueryReset_ ) - {} - - PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 hostQueryReset; - }; - static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceHostQueryResetFeaturesEXT : public layout::PhysicalDeviceHostQueryResetFeaturesEXT + struct PhysicalDeviceHostQueryResetFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceHostQueryResetFeaturesEXT( hostQueryReset_ ) + : hostQueryReset( hostQueryReset_ ) {} + vk::PhysicalDeviceHostQueryResetFeaturesEXT & operator=( vk::PhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceHostQueryResetFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceHostQueryResetFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceHostQueryResetFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47998,56 +43718,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceHostQueryResetFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 hostQueryReset; }; static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceIDProperties { - struct PhysicalDeviceIDProperties + PhysicalDeviceIDProperties( std::array const& deviceUUID_ = { { 0 } }, + std::array const& driverUUID_ = { { 0 } }, + std::array const& deviceLUID_ = { { 0 } }, + uint32_t deviceNodeMask_ = 0, + vk::Bool32 deviceLUIDValid_ = 0 ) VULKAN_HPP_NOEXCEPT + : deviceUUID{} + , driverUUID{} + , deviceLUID{} + , deviceNodeMask( deviceNodeMask_ ) + , deviceLUIDValid( deviceLUIDValid_ ) { - protected: - PhysicalDeviceIDProperties() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( deviceUUID, deviceUUID_ ); + vk::ConstExpressionArrayCopy::copy( driverUUID, driverUUID_ ); + vk::ConstExpressionArrayCopy::copy( deviceLUID, deviceLUID_ ); + } - PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceIdProperties; - void* pNext = nullptr; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - vk::Bool32 deviceLUIDValid; - }; - static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceIDProperties : public layout::PhysicalDeviceIDProperties - { - PhysicalDeviceIDProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceIDProperties() - {} + vk::PhysicalDeviceIDProperties & operator=( vk::PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceIDProperties ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceIDProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceIDProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48077,65 +43787,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceIDProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceIdProperties; + void* pNext = nullptr; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + vk::Bool32 deviceLUIDValid; }; static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceImageDrmFormatModifierInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0, - vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : drmFormatModifier( drmFormatModifier_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - {} - - PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; - const void* pNext = nullptr; - uint64_t drmFormatModifier; - vk::SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - }; - static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceImageDrmFormatModifierInfoEXT : public layout::PhysicalDeviceImageDrmFormatModifierInfoEXT + struct PhysicalDeviceImageDrmFormatModifierInfoEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0, vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( drmFormatModifier_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ ) + : drmFormatModifier( drmFormatModifier_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) {} + vk::PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( vk::PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageDrmFormatModifierInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48194,69 +43883,45 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; + const void* pNext = nullptr; + uint64_t drmFormatModifier; + vk::SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; }; static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceImageFormatInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined, - vk::ImageType type_ = vk::ImageType::e1D, - vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal, - vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), - vk::ImageCreateFlags flags_ = vk::ImageCreateFlags() ) VULKAN_HPP_NOEXCEPT - : format( format_ ) - , type( type_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , flags( flags_ ) - {} - - PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; - const void* pNext = nullptr; - vk::Format format; - vk::ImageType type; - vk::ImageTiling tiling; - vk::ImageUsageFlags usage; - vk::ImageCreateFlags flags; - }; - static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceImageFormatInfo2 : public layout::PhysicalDeviceImageFormatInfo2 + struct PhysicalDeviceImageFormatInfo2 { VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined, vk::ImageType type_ = vk::ImageType::e1D, vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal, vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), vk::ImageCreateFlags flags_ = vk::ImageCreateFlags() ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageFormatInfo2( format_, type_, tiling_, usage_, flags_ ) + : format( format_ ) + , type( type_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , flags( flags_ ) {} + vk::PhysicalDeviceImageFormatInfo2 & operator=( vk::PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageFormatInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageFormatInfo2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceImageFormatInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48322,53 +43987,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceImageFormatInfo2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; + const void* pNext = nullptr; + vk::Format format; + vk::ImageType type; + vk::ImageTiling tiling; + vk::ImageUsageFlags usage; + vk::ImageCreateFlags flags; }; static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceImageViewImageFormatInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT - : imageViewType( imageViewType_ ) - {} - - PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; - void* pNext = nullptr; - vk::ImageViewType imageViewType; - }; - static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceImageViewImageFormatInfoEXT : public layout::PhysicalDeviceImageViewImageFormatInfoEXT + struct PhysicalDeviceImageViewImageFormatInfoEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageViewImageFormatInfoEXT( imageViewType_ ) + : imageViewType( imageViewType_ ) {} + vk::PhysicalDeviceImageViewImageFormatInfoEXT & operator=( vk::PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageViewImageFormatInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageViewImageFormatInfoEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceImageViewImageFormatInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48406,53 +44056,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceImageViewImageFormatInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; + void* pNext = nullptr; + vk::ImageViewType imageViewType; }; static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceImagelessFramebufferFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 ) VULKAN_HPP_NOEXCEPT - : imagelessFramebuffer( imagelessFramebuffer_ ) - {} - - PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 imagelessFramebuffer; - }; - static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceImagelessFramebufferFeaturesKHR : public layout::PhysicalDeviceImagelessFramebufferFeaturesKHR + struct PhysicalDeviceImagelessFramebufferFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( imagelessFramebuffer_ ) + : imagelessFramebuffer( imagelessFramebuffer_ ) {} + vk::PhysicalDeviceImagelessFramebufferFeaturesKHR & operator=( vk::PhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImagelessFramebufferFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48490,53 +44121,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 imagelessFramebuffer; }; static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceIndexTypeUint8FeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 ) VULKAN_HPP_NOEXCEPT - : indexTypeUint8( indexTypeUint8_ ) - {} - - PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT; - void* pNext = nullptr; - vk::Bool32 indexTypeUint8; - }; - static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceIndexTypeUint8FeaturesEXT : public layout::PhysicalDeviceIndexTypeUint8FeaturesEXT + struct PhysicalDeviceIndexTypeUint8FeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( indexTypeUint8_ ) + : indexTypeUint8( indexTypeUint8_ ) {} + vk::PhysicalDeviceIndexTypeUint8FeaturesEXT & operator=( vk::PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceIndexTypeUint8FeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48574,57 +44186,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT; + void* pNext = nullptr; + vk::Bool32 indexTypeUint8; }; static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceInlineUniformBlockFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0, - vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 ) VULKAN_HPP_NOEXCEPT - : inlineUniformBlock( inlineUniformBlock_ ) - , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ ) - {} - - PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 inlineUniformBlock; - vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind; - }; - static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceInlineUniformBlockFeaturesEXT : public layout::PhysicalDeviceInlineUniformBlockFeaturesEXT + struct PhysicalDeviceInlineUniformBlockFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0, vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( inlineUniformBlock_, descriptorBindingInlineUniformBlockUpdateAfterBind_ ) + : inlineUniformBlock( inlineUniformBlock_ ) + , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ ) {} + vk::PhysicalDeviceInlineUniformBlockFeaturesEXT & operator=( vk::PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceInlineUniformBlockFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48669,56 +44260,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 inlineUniformBlock; + vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind; }; static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceInlineUniformBlockPropertiesEXT { - struct PhysicalDeviceInlineUniformBlockPropertiesEXT - { - protected: - PhysicalDeviceInlineUniformBlockPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT; - void* pNext = nullptr; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; - }; - static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceInlineUniformBlockPropertiesEXT : public layout::PhysicalDeviceInlineUniformBlockPropertiesEXT - { - PhysicalDeviceInlineUniformBlockPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceInlineUniformBlockPropertiesEXT() + PhysicalDeviceInlineUniformBlockPropertiesEXT( uint32_t maxInlineUniformBlockSize_ = 0, + uint32_t maxPerStageDescriptorInlineUniformBlocks_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = 0, + uint32_t maxDescriptorSetInlineUniformBlocks_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxInlineUniformBlockSize( maxInlineUniformBlockSize_ ) + , maxPerStageDescriptorInlineUniformBlocks( maxPerStageDescriptorInlineUniformBlocks_ ) + , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ ) + , maxDescriptorSetInlineUniformBlocks( maxDescriptorSetInlineUniformBlocks_ ) + , maxDescriptorSetUpdateAfterBindInlineUniformBlocks( maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ ) {} + vk::PhysicalDeviceInlineUniformBlockPropertiesEXT & operator=( vk::PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceInlineUniformBlockPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceInlineUniformBlockPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48748,25 +44326,249 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT; + void* pNext = nullptr; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; }; static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceLimits { - PhysicalDeviceLimits() VULKAN_HPP_NOEXCEPT - {} + PhysicalDeviceLimits( uint32_t maxImageDimension1D_ = 0, + uint32_t maxImageDimension2D_ = 0, + uint32_t maxImageDimension3D_ = 0, + uint32_t maxImageDimensionCube_ = 0, + uint32_t maxImageArrayLayers_ = 0, + uint32_t maxTexelBufferElements_ = 0, + uint32_t maxUniformBufferRange_ = 0, + uint32_t maxStorageBufferRange_ = 0, + uint32_t maxPushConstantsSize_ = 0, + uint32_t maxMemoryAllocationCount_ = 0, + uint32_t maxSamplerAllocationCount_ = 0, + vk::DeviceSize bufferImageGranularity_ = 0, + vk::DeviceSize sparseAddressSpaceSize_ = 0, + uint32_t maxBoundDescriptorSets_ = 0, + uint32_t maxPerStageDescriptorSamplers_ = 0, + uint32_t maxPerStageDescriptorUniformBuffers_ = 0, + uint32_t maxPerStageDescriptorStorageBuffers_ = 0, + uint32_t maxPerStageDescriptorSampledImages_ = 0, + uint32_t maxPerStageDescriptorStorageImages_ = 0, + uint32_t maxPerStageDescriptorInputAttachments_ = 0, + uint32_t maxPerStageResources_ = 0, + uint32_t maxDescriptorSetSamplers_ = 0, + uint32_t maxDescriptorSetUniformBuffers_ = 0, + uint32_t maxDescriptorSetUniformBuffersDynamic_ = 0, + uint32_t maxDescriptorSetStorageBuffers_ = 0, + uint32_t maxDescriptorSetStorageBuffersDynamic_ = 0, + uint32_t maxDescriptorSetSampledImages_ = 0, + uint32_t maxDescriptorSetStorageImages_ = 0, + uint32_t maxDescriptorSetInputAttachments_ = 0, + uint32_t maxVertexInputAttributes_ = 0, + uint32_t maxVertexInputBindings_ = 0, + uint32_t maxVertexInputAttributeOffset_ = 0, + uint32_t maxVertexInputBindingStride_ = 0, + uint32_t maxVertexOutputComponents_ = 0, + uint32_t maxTessellationGenerationLevel_ = 0, + uint32_t maxTessellationPatchSize_ = 0, + uint32_t maxTessellationControlPerVertexInputComponents_ = 0, + uint32_t maxTessellationControlPerVertexOutputComponents_ = 0, + uint32_t maxTessellationControlPerPatchOutputComponents_ = 0, + uint32_t maxTessellationControlTotalOutputComponents_ = 0, + uint32_t maxTessellationEvaluationInputComponents_ = 0, + uint32_t maxTessellationEvaluationOutputComponents_ = 0, + uint32_t maxGeometryShaderInvocations_ = 0, + uint32_t maxGeometryInputComponents_ = 0, + uint32_t maxGeometryOutputComponents_ = 0, + uint32_t maxGeometryOutputVertices_ = 0, + uint32_t maxGeometryTotalOutputComponents_ = 0, + uint32_t maxFragmentInputComponents_ = 0, + uint32_t maxFragmentOutputAttachments_ = 0, + uint32_t maxFragmentDualSrcAttachments_ = 0, + uint32_t maxFragmentCombinedOutputResources_ = 0, + uint32_t maxComputeSharedMemorySize_ = 0, + std::array const& maxComputeWorkGroupCount_ = { { 0 } }, + uint32_t maxComputeWorkGroupInvocations_ = 0, + std::array const& maxComputeWorkGroupSize_ = { { 0 } }, + uint32_t subPixelPrecisionBits_ = 0, + uint32_t subTexelPrecisionBits_ = 0, + uint32_t mipmapPrecisionBits_ = 0, + uint32_t maxDrawIndexedIndexValue_ = 0, + uint32_t maxDrawIndirectCount_ = 0, + float maxSamplerLodBias_ = 0, + float maxSamplerAnisotropy_ = 0, + uint32_t maxViewports_ = 0, + std::array const& maxViewportDimensions_ = { { 0 } }, + std::array const& viewportBoundsRange_ = { { 0 } }, + uint32_t viewportSubPixelBits_ = 0, + size_t minMemoryMapAlignment_ = 0, + vk::DeviceSize minTexelBufferOffsetAlignment_ = 0, + vk::DeviceSize minUniformBufferOffsetAlignment_ = 0, + vk::DeviceSize minStorageBufferOffsetAlignment_ = 0, + int32_t minTexelOffset_ = 0, + uint32_t maxTexelOffset_ = 0, + int32_t minTexelGatherOffset_ = 0, + uint32_t maxTexelGatherOffset_ = 0, + float minInterpolationOffset_ = 0, + float maxInterpolationOffset_ = 0, + uint32_t subPixelInterpolationOffsetBits_ = 0, + uint32_t maxFramebufferWidth_ = 0, + uint32_t maxFramebufferHeight_ = 0, + uint32_t maxFramebufferLayers_ = 0, + vk::SampleCountFlags framebufferColorSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags framebufferDepthSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags framebufferStencilSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags framebufferNoAttachmentsSampleCounts_ = vk::SampleCountFlags(), + uint32_t maxColorAttachments_ = 0, + vk::SampleCountFlags sampledImageColorSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags sampledImageIntegerSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags sampledImageDepthSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags sampledImageStencilSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags storageImageSampleCounts_ = vk::SampleCountFlags(), + uint32_t maxSampleMaskWords_ = 0, + vk::Bool32 timestampComputeAndGraphics_ = 0, + float timestampPeriod_ = 0, + uint32_t maxClipDistances_ = 0, + uint32_t maxCullDistances_ = 0, + uint32_t maxCombinedClipAndCullDistances_ = 0, + uint32_t discreteQueuePriorities_ = 0, + std::array const& pointSizeRange_ = { { 0 } }, + std::array const& lineWidthRange_ = { { 0 } }, + float pointSizeGranularity_ = 0, + float lineWidthGranularity_ = 0, + vk::Bool32 strictLines_ = 0, + vk::Bool32 standardSampleLocations_ = 0, + vk::DeviceSize optimalBufferCopyOffsetAlignment_ = 0, + vk::DeviceSize optimalBufferCopyRowPitchAlignment_ = 0, + vk::DeviceSize nonCoherentAtomSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxImageDimension1D( maxImageDimension1D_ ) + , maxImageDimension2D( maxImageDimension2D_ ) + , maxImageDimension3D( maxImageDimension3D_ ) + , maxImageDimensionCube( maxImageDimensionCube_ ) + , maxImageArrayLayers( maxImageArrayLayers_ ) + , maxTexelBufferElements( maxTexelBufferElements_ ) + , maxUniformBufferRange( maxUniformBufferRange_ ) + , maxStorageBufferRange( maxStorageBufferRange_ ) + , maxPushConstantsSize( maxPushConstantsSize_ ) + , maxMemoryAllocationCount( maxMemoryAllocationCount_ ) + , maxSamplerAllocationCount( maxSamplerAllocationCount_ ) + , bufferImageGranularity( bufferImageGranularity_ ) + , sparseAddressSpaceSize( sparseAddressSpaceSize_ ) + , maxBoundDescriptorSets( maxBoundDescriptorSets_ ) + , maxPerStageDescriptorSamplers( maxPerStageDescriptorSamplers_ ) + , maxPerStageDescriptorUniformBuffers( maxPerStageDescriptorUniformBuffers_ ) + , maxPerStageDescriptorStorageBuffers( maxPerStageDescriptorStorageBuffers_ ) + , maxPerStageDescriptorSampledImages( maxPerStageDescriptorSampledImages_ ) + , maxPerStageDescriptorStorageImages( maxPerStageDescriptorStorageImages_ ) + , maxPerStageDescriptorInputAttachments( maxPerStageDescriptorInputAttachments_ ) + , maxPerStageResources( maxPerStageResources_ ) + , maxDescriptorSetSamplers( maxDescriptorSetSamplers_ ) + , maxDescriptorSetUniformBuffers( maxDescriptorSetUniformBuffers_ ) + , maxDescriptorSetUniformBuffersDynamic( maxDescriptorSetUniformBuffersDynamic_ ) + , maxDescriptorSetStorageBuffers( maxDescriptorSetStorageBuffers_ ) + , maxDescriptorSetStorageBuffersDynamic( maxDescriptorSetStorageBuffersDynamic_ ) + , maxDescriptorSetSampledImages( maxDescriptorSetSampledImages_ ) + , maxDescriptorSetStorageImages( maxDescriptorSetStorageImages_ ) + , maxDescriptorSetInputAttachments( maxDescriptorSetInputAttachments_ ) + , maxVertexInputAttributes( maxVertexInputAttributes_ ) + , maxVertexInputBindings( maxVertexInputBindings_ ) + , maxVertexInputAttributeOffset( maxVertexInputAttributeOffset_ ) + , maxVertexInputBindingStride( maxVertexInputBindingStride_ ) + , maxVertexOutputComponents( maxVertexOutputComponents_ ) + , maxTessellationGenerationLevel( maxTessellationGenerationLevel_ ) + , maxTessellationPatchSize( maxTessellationPatchSize_ ) + , maxTessellationControlPerVertexInputComponents( maxTessellationControlPerVertexInputComponents_ ) + , maxTessellationControlPerVertexOutputComponents( maxTessellationControlPerVertexOutputComponents_ ) + , maxTessellationControlPerPatchOutputComponents( maxTessellationControlPerPatchOutputComponents_ ) + , maxTessellationControlTotalOutputComponents( maxTessellationControlTotalOutputComponents_ ) + , maxTessellationEvaluationInputComponents( maxTessellationEvaluationInputComponents_ ) + , maxTessellationEvaluationOutputComponents( maxTessellationEvaluationOutputComponents_ ) + , maxGeometryShaderInvocations( maxGeometryShaderInvocations_ ) + , maxGeometryInputComponents( maxGeometryInputComponents_ ) + , maxGeometryOutputComponents( maxGeometryOutputComponents_ ) + , maxGeometryOutputVertices( maxGeometryOutputVertices_ ) + , maxGeometryTotalOutputComponents( maxGeometryTotalOutputComponents_ ) + , maxFragmentInputComponents( maxFragmentInputComponents_ ) + , maxFragmentOutputAttachments( maxFragmentOutputAttachments_ ) + , maxFragmentDualSrcAttachments( maxFragmentDualSrcAttachments_ ) + , maxFragmentCombinedOutputResources( maxFragmentCombinedOutputResources_ ) + , maxComputeSharedMemorySize( maxComputeSharedMemorySize_ ) + , maxComputeWorkGroupCount{} + , maxComputeWorkGroupInvocations( maxComputeWorkGroupInvocations_ ) + , maxComputeWorkGroupSize{} + , subPixelPrecisionBits( subPixelPrecisionBits_ ) + , subTexelPrecisionBits( subTexelPrecisionBits_ ) + , mipmapPrecisionBits( mipmapPrecisionBits_ ) + , maxDrawIndexedIndexValue( maxDrawIndexedIndexValue_ ) + , maxDrawIndirectCount( maxDrawIndirectCount_ ) + , maxSamplerLodBias( maxSamplerLodBias_ ) + , maxSamplerAnisotropy( maxSamplerAnisotropy_ ) + , maxViewports( maxViewports_ ) + , maxViewportDimensions{} + , viewportBoundsRange{} + , viewportSubPixelBits( viewportSubPixelBits_ ) + , minMemoryMapAlignment( minMemoryMapAlignment_ ) + , minTexelBufferOffsetAlignment( minTexelBufferOffsetAlignment_ ) + , minUniformBufferOffsetAlignment( minUniformBufferOffsetAlignment_ ) + , minStorageBufferOffsetAlignment( minStorageBufferOffsetAlignment_ ) + , minTexelOffset( minTexelOffset_ ) + , maxTexelOffset( maxTexelOffset_ ) + , minTexelGatherOffset( minTexelGatherOffset_ ) + , maxTexelGatherOffset( maxTexelGatherOffset_ ) + , minInterpolationOffset( minInterpolationOffset_ ) + , maxInterpolationOffset( maxInterpolationOffset_ ) + , subPixelInterpolationOffsetBits( subPixelInterpolationOffsetBits_ ) + , maxFramebufferWidth( maxFramebufferWidth_ ) + , maxFramebufferHeight( maxFramebufferHeight_ ) + , maxFramebufferLayers( maxFramebufferLayers_ ) + , framebufferColorSampleCounts( framebufferColorSampleCounts_ ) + , framebufferDepthSampleCounts( framebufferDepthSampleCounts_ ) + , framebufferStencilSampleCounts( framebufferStencilSampleCounts_ ) + , framebufferNoAttachmentsSampleCounts( framebufferNoAttachmentsSampleCounts_ ) + , maxColorAttachments( maxColorAttachments_ ) + , sampledImageColorSampleCounts( sampledImageColorSampleCounts_ ) + , sampledImageIntegerSampleCounts( sampledImageIntegerSampleCounts_ ) + , sampledImageDepthSampleCounts( sampledImageDepthSampleCounts_ ) + , sampledImageStencilSampleCounts( sampledImageStencilSampleCounts_ ) + , storageImageSampleCounts( storageImageSampleCounts_ ) + , maxSampleMaskWords( maxSampleMaskWords_ ) + , timestampComputeAndGraphics( timestampComputeAndGraphics_ ) + , timestampPeriod( timestampPeriod_ ) + , maxClipDistances( maxClipDistances_ ) + , maxCullDistances( maxCullDistances_ ) + , maxCombinedClipAndCullDistances( maxCombinedClipAndCullDistances_ ) + , discreteQueuePriorities( discreteQueuePriorities_ ) + , pointSizeRange{} + , lineWidthRange{} + , pointSizeGranularity( pointSizeGranularity_ ) + , lineWidthGranularity( lineWidthGranularity_ ) + , strictLines( strictLines_ ) + , standardSampleLocations( standardSampleLocations_ ) + , optimalBufferCopyOffsetAlignment( optimalBufferCopyOffsetAlignment_ ) + , optimalBufferCopyRowPitchAlignment( optimalBufferCopyRowPitchAlignment_ ) + , nonCoherentAtomSize( nonCoherentAtomSize_ ) + { + vk::ConstExpressionArrayCopy::copy( maxComputeWorkGroupCount, maxComputeWorkGroupCount_ ); + vk::ConstExpressionArrayCopy::copy( maxComputeWorkGroupSize, maxComputeWorkGroupSize_ ); + vk::ConstExpressionArrayCopy::copy( maxViewportDimensions, maxViewportDimensions_ ); + vk::ConstExpressionArrayCopy::copy( viewportBoundsRange, viewportBoundsRange_ ); + vk::ConstExpressionArrayCopy::copy( pointSizeRange, pointSizeRange_ ); + vk::ConstExpressionArrayCopy::copy( lineWidthRange, lineWidthRange_ ); + } PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceLimits& operator=( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -49006,50 +44808,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceLineRasterizationFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0, - vk::Bool32 bresenhamLines_ = 0, - vk::Bool32 smoothLines_ = 0, - vk::Bool32 stippledRectangularLines_ = 0, - vk::Bool32 stippledBresenhamLines_ = 0, - vk::Bool32 stippledSmoothLines_ = 0 ) VULKAN_HPP_NOEXCEPT - : rectangularLines( rectangularLines_ ) - , bresenhamLines( bresenhamLines_ ) - , smoothLines( smoothLines_ ) - , stippledRectangularLines( stippledRectangularLines_ ) - , stippledBresenhamLines( stippledBresenhamLines_ ) - , stippledSmoothLines( stippledSmoothLines_ ) - {} - - PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 rectangularLines; - vk::Bool32 bresenhamLines; - vk::Bool32 smoothLines; - vk::Bool32 stippledRectangularLines; - vk::Bool32 stippledBresenhamLines; - vk::Bool32 stippledSmoothLines; - }; - static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceLineRasterizationFeaturesEXT : public layout::PhysicalDeviceLineRasterizationFeaturesEXT + struct PhysicalDeviceLineRasterizationFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0, vk::Bool32 bresenhamLines_ = 0, @@ -49057,16 +44816,28 @@ namespace VULKAN_HPP_NAMESPACE vk::Bool32 stippledRectangularLines_ = 0, vk::Bool32 stippledBresenhamLines_ = 0, vk::Bool32 stippledSmoothLines_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rectangularLines_, bresenhamLines_, smoothLines_, stippledRectangularLines_, stippledBresenhamLines_, stippledSmoothLines_ ) + : rectangularLines( rectangularLines_ ) + , bresenhamLines( bresenhamLines_ ) + , smoothLines( smoothLines_ ) + , stippledRectangularLines( stippledRectangularLines_ ) + , stippledBresenhamLines( stippledBresenhamLines_ ) + , stippledSmoothLines( stippledSmoothLines_ ) {} + vk::PhysicalDeviceLineRasterizationFeaturesEXT & operator=( vk::PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceLineRasterizationFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceLineRasterizationFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49139,52 +44910,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceLineRasterizationFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 rectangularLines; + vk::Bool32 bresenhamLines; + vk::Bool32 smoothLines; + vk::Bool32 stippledRectangularLines; + vk::Bool32 stippledBresenhamLines; + vk::Bool32 stippledSmoothLines; }; static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceLineRasterizationPropertiesEXT { - struct PhysicalDeviceLineRasterizationPropertiesEXT - { - protected: - PhysicalDeviceLineRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT; - void* pNext = nullptr; - uint32_t lineSubPixelPrecisionBits; - }; - static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceLineRasterizationPropertiesEXT : public layout::PhysicalDeviceLineRasterizationPropertiesEXT - { - PhysicalDeviceLineRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceLineRasterizationPropertiesEXT() + PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ ) {} + vk::PhysicalDeviceLineRasterizationPropertiesEXT & operator=( vk::PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceLineRasterizationPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceLineRasterizationPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceLineRasterizationPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49210,53 +44968,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceLineRasterizationPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT; + void* pNext = nullptr; + uint32_t lineSubPixelPrecisionBits; }; static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMaintenance3Properties { - struct PhysicalDeviceMaintenance3Properties - { - protected: - PhysicalDeviceMaintenance3Properties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; - void* pNext = nullptr; - uint32_t maxPerSetDescriptors; - vk::DeviceSize maxMemoryAllocationSize; - }; - static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMaintenance3Properties : public layout::PhysicalDeviceMaintenance3Properties - { - PhysicalDeviceMaintenance3Properties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMaintenance3Properties() + PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = 0, + vk::DeviceSize maxMemoryAllocationSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxPerSetDescriptors( maxPerSetDescriptors_ ) + , maxMemoryAllocationSize( maxMemoryAllocationSize_ ) {} + vk::PhysicalDeviceMaintenance3Properties & operator=( vk::PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMaintenance3Properties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMaintenance3Properties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMaintenance3Properties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49283,53 +45024,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMaintenance3Properties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; + void* pNext = nullptr; + uint32_t maxPerSetDescriptors; + vk::DeviceSize maxMemoryAllocationSize; }; static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMemoryBudgetPropertiesEXT { - struct PhysicalDeviceMemoryBudgetPropertiesEXT + PhysicalDeviceMemoryBudgetPropertiesEXT( std::array const& heapBudget_ = { { 0 } }, + std::array const& heapUsage_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT + : heapBudget{} + , heapUsage{} { - protected: - PhysicalDeviceMemoryBudgetPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( heapBudget, heapBudget_ ); + vk::ConstExpressionArrayCopy::copy( heapUsage, heapUsage_ ); + } - PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; - void* pNext = nullptr; - vk::DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; - vk::DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; - }; - static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMemoryBudgetPropertiesEXT : public layout::PhysicalDeviceMemoryBudgetPropertiesEXT - { - PhysicalDeviceMemoryBudgetPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryBudgetPropertiesEXT() - {} + vk::PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( vk::PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryBudgetPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryBudgetPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMemoryBudgetPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49356,53 +45084,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMemoryBudgetPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; + void* pNext = nullptr; + vk::DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + vk::DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; }; static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceMemoryPriorityFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 ) VULKAN_HPP_NOEXCEPT - : memoryPriority( memoryPriority_ ) - {} - - PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 memoryPriority; - }; - static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMemoryPriorityFeaturesEXT : public layout::PhysicalDeviceMemoryPriorityFeaturesEXT + struct PhysicalDeviceMemoryPriorityFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( memoryPriority_ ) + : memoryPriority( memoryPriority_ ) {} + vk::PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( vk::PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryPriorityFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMemoryPriorityFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49440,25 +45150,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMemoryPriorityFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 memoryPriority; }; static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceMemoryProperties { - PhysicalDeviceMemoryProperties() VULKAN_HPP_NOEXCEPT - {} + PhysicalDeviceMemoryProperties( uint32_t memoryTypeCount_ = 0, + std::array const& memoryTypes_ = { { vk::MemoryType() } }, + uint32_t memoryHeapCount_ = 0, + std::array const& memoryHeaps_ = { { vk::MemoryHeap() } } ) VULKAN_HPP_NOEXCEPT + : memoryTypeCount( memoryTypeCount_ ) + , memoryTypes{} + , memoryHeapCount( memoryHeapCount_ ) + , memoryHeaps{} + { + vk::ConstExpressionArrayCopy::copy( memoryTypes, memoryTypes_ ); + vk::ConstExpressionArrayCopy::copy( memoryHeaps, memoryHeaps_ ); + } PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceMemoryProperties& operator=( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -49494,46 +45216,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMemoryProperties2 { - struct PhysicalDeviceMemoryProperties2 - { - protected: - PhysicalDeviceMemoryProperties2() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; - void* pNext = nullptr; - vk::PhysicalDeviceMemoryProperties memoryProperties; - }; - static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMemoryProperties2 : public layout::PhysicalDeviceMemoryProperties2 - { - PhysicalDeviceMemoryProperties2() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryProperties2() + PhysicalDeviceMemoryProperties2( vk::PhysicalDeviceMemoryProperties memoryProperties_ = vk::PhysicalDeviceMemoryProperties() ) VULKAN_HPP_NOEXCEPT + : memoryProperties( memoryProperties_ ) {} + vk::PhysicalDeviceMemoryProperties2 & operator=( vk::PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryProperties2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMemoryProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49559,57 +45261,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMemoryProperties2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; + void* pNext = nullptr; + vk::PhysicalDeviceMemoryProperties memoryProperties; }; static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceMeshShaderFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0, - vk::Bool32 meshShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : taskShader( taskShader_ ) - , meshShader( meshShader_ ) - {} - - PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; - void* pNext = nullptr; - vk::Bool32 taskShader; - vk::Bool32 meshShader; - }; - static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMeshShaderFeaturesNV : public layout::PhysicalDeviceMeshShaderFeaturesNV + struct PhysicalDeviceMeshShaderFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0, vk::Bool32 meshShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMeshShaderFeaturesNV( taskShader_, meshShader_ ) + : taskShader( taskShader_ ) + , meshShader( meshShader_ ) {} + vk::PhysicalDeviceMeshShaderFeaturesNV & operator=( vk::PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMeshShaderFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMeshShaderFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMeshShaderFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49654,64 +45335,62 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMeshShaderFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; + void* pNext = nullptr; + vk::Bool32 taskShader; + vk::Bool32 meshShader; }; static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMeshShaderPropertiesNV { - struct PhysicalDeviceMeshShaderPropertiesNV + PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = 0, + uint32_t maxTaskWorkGroupInvocations_ = 0, + std::array const& maxTaskWorkGroupSize_ = { { 0 } }, + uint32_t maxTaskTotalMemorySize_ = 0, + uint32_t maxTaskOutputCount_ = 0, + uint32_t maxMeshWorkGroupInvocations_ = 0, + std::array const& maxMeshWorkGroupSize_ = { { 0 } }, + uint32_t maxMeshTotalMemorySize_ = 0, + uint32_t maxMeshOutputVertices_ = 0, + uint32_t maxMeshOutputPrimitives_ = 0, + uint32_t maxMeshMultiviewViewCount_ = 0, + uint32_t meshOutputPerVertexGranularity_ = 0, + uint32_t meshOutputPerPrimitiveGranularity_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ ) + , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ ) + , maxTaskWorkGroupSize{} + , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ ) + , maxTaskOutputCount( maxTaskOutputCount_ ) + , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ ) + , maxMeshWorkGroupSize{} + , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ ) + , maxMeshOutputVertices( maxMeshOutputVertices_ ) + , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ ) + , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ ) + , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ ) + , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ ) { - protected: - PhysicalDeviceMeshShaderPropertiesNV() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( maxTaskWorkGroupSize, maxTaskWorkGroupSize_ ); + vk::ConstExpressionArrayCopy::copy( maxMeshWorkGroupSize, maxMeshWorkGroupSize_ ); + } - PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; - void* pNext = nullptr; - uint32_t maxDrawMeshTasksCount; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskTotalMemorySize; - uint32_t maxTaskOutputCount; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshTotalMemorySize; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; - }; - static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMeshShaderPropertiesNV : public layout::PhysicalDeviceMeshShaderPropertiesNV - { - PhysicalDeviceMeshShaderPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMeshShaderPropertiesNV() - {} + vk::PhysicalDeviceMeshShaderPropertiesNV & operator=( vk::PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMeshShaderPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMeshShaderPropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMeshShaderPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49749,61 +45428,50 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMeshShaderPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; + void* pNext = nullptr; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; }; static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceMultiviewFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0, - vk::Bool32 multiviewGeometryShader_ = 0, - vk::Bool32 multiviewTessellationShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : multiview( multiview_ ) - , multiviewGeometryShader( multiviewGeometryShader_ ) - , multiviewTessellationShader( multiviewTessellationShader_ ) - {} - - PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; - void* pNext = nullptr; - vk::Bool32 multiview; - vk::Bool32 multiviewGeometryShader; - vk::Bool32 multiviewTessellationShader; - }; - static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMultiviewFeatures : public layout::PhysicalDeviceMultiviewFeatures + struct PhysicalDeviceMultiviewFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0, vk::Bool32 multiviewGeometryShader_ = 0, vk::Bool32 multiviewTessellationShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewFeatures( multiview_, multiviewGeometryShader_, multiviewTessellationShader_ ) + : multiview( multiview_ ) + , multiviewGeometryShader( multiviewGeometryShader_ ) + , multiviewTessellationShader( multiviewTessellationShader_ ) {} + vk::PhysicalDeviceMultiviewFeatures & operator=( vk::PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMultiviewFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49855,52 +45523,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMultiviewFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; + void* pNext = nullptr; + vk::Bool32 multiview; + vk::Bool32 multiviewGeometryShader; + vk::Bool32 multiviewTessellationShader; }; static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX - { - protected: - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - void* pNext = nullptr; - vk::Bool32 perViewPositionAllComponents; - }; - static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : public layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX - { - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( vk::Bool32 perViewPositionAllComponents_ = 0 ) VULKAN_HPP_NOEXCEPT + : perViewPositionAllComponents( perViewPositionAllComponents_ ) {} + vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & operator=( vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49926,53 +45578,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + void* pNext = nullptr; + vk::Bool32 perViewPositionAllComponents; }; static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMultiviewProperties { - struct PhysicalDeviceMultiviewProperties - { - protected: - PhysicalDeviceMultiviewProperties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; - void* pNext = nullptr; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; - }; - static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMultiviewProperties : public layout::PhysicalDeviceMultiviewProperties - { - PhysicalDeviceMultiviewProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewProperties() + PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = 0, + uint32_t maxMultiviewInstanceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxMultiviewViewCount( maxMultiviewViewCount_ ) + , maxMultiviewInstanceIndex( maxMultiviewInstanceIndex_ ) {} + vk::PhysicalDeviceMultiviewProperties & operator=( vk::PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMultiviewProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49999,55 +45634,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMultiviewProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; + void* pNext = nullptr; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; }; static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDevicePCIBusInfoPropertiesEXT { - struct PhysicalDevicePCIBusInfoPropertiesEXT - { - protected: - PhysicalDevicePCIBusInfoPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; - void* pNext = nullptr; - uint32_t pciDomain; - uint32_t pciBus; - uint32_t pciDevice; - uint32_t pciFunction; - }; - static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevicePCIBusInfoPropertiesEXT : public layout::PhysicalDevicePCIBusInfoPropertiesEXT - { - PhysicalDevicePCIBusInfoPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePCIBusInfoPropertiesEXT() + PhysicalDevicePCIBusInfoPropertiesEXT( uint32_t pciDomain_ = 0, + uint32_t pciBus_ = 0, + uint32_t pciDevice_ = 0, + uint32_t pciFunction_ = 0 ) VULKAN_HPP_NOEXCEPT + : pciDomain( pciDomain_ ) + , pciBus( pciBus_ ) + , pciDevice( pciDevice_ ) + , pciFunction( pciFunction_ ) {} + vk::PhysicalDevicePCIBusInfoPropertiesEXT & operator=( vk::PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePCIBusInfoPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePCIBusInfoPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevicePCIBusInfoPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50076,53 +45697,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevicePCIBusInfoPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; + void* pNext = nullptr; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; }; static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 ) VULKAN_HPP_NOEXCEPT - : pipelineExecutableInfo( pipelineExecutableInfo_ ) - {} - - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 pipelineExecutableInfo; - }; - static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR : public layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( pipelineExecutableInfo_ ) + : pipelineExecutableInfo( pipelineExecutableInfo_ ) {} + vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & operator=( vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50160,52 +45765,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 pipelineExecutableInfo; }; static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDevicePointClippingProperties { - struct PhysicalDevicePointClippingProperties - { - protected: - PhysicalDevicePointClippingProperties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; - void* pNext = nullptr; - vk::PointClippingBehavior pointClippingBehavior; - }; - static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevicePointClippingProperties : public layout::PhysicalDevicePointClippingProperties - { - PhysicalDevicePointClippingProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePointClippingProperties() + PhysicalDevicePointClippingProperties( vk::PointClippingBehavior pointClippingBehavior_ = vk::PointClippingBehavior::eAllClipPlanes ) VULKAN_HPP_NOEXCEPT + : pointClippingBehavior( pointClippingBehavior_ ) {} + vk::PhysicalDevicePointClippingProperties & operator=( vk::PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePointClippingProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePointClippingProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevicePointClippingProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50231,25 +45818,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevicePointClippingProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; + void* pNext = nullptr; + vk::PointClippingBehavior pointClippingBehavior; }; static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceSparseProperties { - PhysicalDeviceSparseProperties() VULKAN_HPP_NOEXCEPT + PhysicalDeviceSparseProperties( vk::Bool32 residencyStandard2DBlockShape_ = 0, + vk::Bool32 residencyStandard2DMultisampleBlockShape_ = 0, + vk::Bool32 residencyStandard3DBlockShape_ = 0, + vk::Bool32 residencyAlignedMipSize_ = 0, + vk::Bool32 residencyNonResidentStrict_ = 0 ) VULKAN_HPP_NOEXCEPT + : residencyStandard2DBlockShape( residencyStandard2DBlockShape_ ) + , residencyStandard2DMultisampleBlockShape( residencyStandard2DMultisampleBlockShape_ ) + , residencyStandard3DBlockShape( residencyStandard3DBlockShape_ ) + , residencyAlignedMipSize( residencyAlignedMipSize_ ) + , residencyNonResidentStrict( residencyNonResidentStrict_ ) {} PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceSparseProperties& operator=( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -50289,17 +45887,37 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceProperties { - PhysicalDeviceProperties() VULKAN_HPP_NOEXCEPT - {} + PhysicalDeviceProperties( uint32_t apiVersion_ = 0, + uint32_t driverVersion_ = 0, + uint32_t vendorID_ = 0, + uint32_t deviceID_ = 0, + vk::PhysicalDeviceType deviceType_ = vk::PhysicalDeviceType::eOther, + std::array const& deviceName_ = { { 0 } }, + std::array const& pipelineCacheUUID_ = { { 0 } }, + vk::PhysicalDeviceLimits limits_ = vk::PhysicalDeviceLimits(), + vk::PhysicalDeviceSparseProperties sparseProperties_ = vk::PhysicalDeviceSparseProperties() ) VULKAN_HPP_NOEXCEPT + : apiVersion( apiVersion_ ) + , driverVersion( driverVersion_ ) + , vendorID( vendorID_ ) + , deviceID( deviceID_ ) + , deviceType( deviceType_ ) + , deviceName{} + , pipelineCacheUUID{} + , limits( limits_ ) + , sparseProperties( sparseProperties_ ) + { + vk::ConstExpressionArrayCopy::copy( deviceName, deviceName_ ); + vk::ConstExpressionArrayCopy::copy( pipelineCacheUUID, pipelineCacheUUID_ ); + } PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceProperties& operator=( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -50345,46 +45963,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceProperties2 { - struct PhysicalDeviceProperties2 - { - protected: - PhysicalDeviceProperties2() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceProperties2; - void* pNext = nullptr; - vk::PhysicalDeviceProperties properties; - }; - static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceProperties2 : public layout::PhysicalDeviceProperties2 - { - PhysicalDeviceProperties2() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProperties2() + PhysicalDeviceProperties2( vk::PhysicalDeviceProperties properties_ = vk::PhysicalDeviceProperties() ) VULKAN_HPP_NOEXCEPT + : properties( properties_ ) {} + vk::PhysicalDeviceProperties2 & operator=( vk::PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProperties2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50410,53 +46008,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceProperties2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceProperties2; + void* pNext = nullptr; + vk::PhysicalDeviceProperties properties; }; static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceProtectedMemoryFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 ) VULKAN_HPP_NOEXCEPT - : protectedMemory( protectedMemory_ ) - {} - - PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; - void* pNext = nullptr; - vk::Bool32 protectedMemory; - }; - static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceProtectedMemoryFeatures : public layout::PhysicalDeviceProtectedMemoryFeatures + struct PhysicalDeviceProtectedMemoryFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProtectedMemoryFeatures( protectedMemory_ ) + : protectedMemory( protectedMemory_ ) {} + vk::PhysicalDeviceProtectedMemoryFeatures & operator=( vk::PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProtectedMemoryFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProtectedMemoryFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceProtectedMemoryFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50494,52 +46073,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceProtectedMemoryFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; + void* pNext = nullptr; + vk::Bool32 protectedMemory; }; static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceProtectedMemoryProperties { - struct PhysicalDeviceProtectedMemoryProperties - { - protected: - PhysicalDeviceProtectedMemoryProperties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; - void* pNext = nullptr; - vk::Bool32 protectedNoFault; - }; - static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceProtectedMemoryProperties : public layout::PhysicalDeviceProtectedMemoryProperties - { - PhysicalDeviceProtectedMemoryProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProtectedMemoryProperties() + PhysicalDeviceProtectedMemoryProperties( vk::Bool32 protectedNoFault_ = 0 ) VULKAN_HPP_NOEXCEPT + : protectedNoFault( protectedNoFault_ ) {} + vk::PhysicalDeviceProtectedMemoryProperties & operator=( vk::PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProtectedMemoryProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProtectedMemoryProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceProtectedMemoryProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50565,52 +46126,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceProtectedMemoryProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; + void* pNext = nullptr; + vk::Bool32 protectedNoFault; }; static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDevicePushDescriptorPropertiesKHR { - struct PhysicalDevicePushDescriptorPropertiesKHR - { - protected: - PhysicalDevicePushDescriptorPropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; - void* pNext = nullptr; - uint32_t maxPushDescriptors; - }; - static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevicePushDescriptorPropertiesKHR : public layout::PhysicalDevicePushDescriptorPropertiesKHR - { - PhysicalDevicePushDescriptorPropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePushDescriptorPropertiesKHR() + PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxPushDescriptors( maxPushDescriptors_ ) {} + vk::PhysicalDevicePushDescriptorPropertiesKHR & operator=( vk::PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePushDescriptorPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePushDescriptorPropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevicePushDescriptorPropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50636,59 +46179,48 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevicePushDescriptorPropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; + void* pNext = nullptr; + uint32_t maxPushDescriptors; }; static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceRayTracingPropertiesNV { - struct PhysicalDeviceRayTracingPropertiesNV - { - protected: - PhysicalDeviceRayTracingPropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; - void* pNext = nullptr; - uint32_t shaderGroupHandleSize; - uint32_t maxRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint64_t maxGeometryCount; - uint64_t maxInstanceCount; - uint64_t maxTriangleCount; - uint32_t maxDescriptorSetAccelerationStructures; - }; - static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceRayTracingPropertiesNV : public layout::PhysicalDeviceRayTracingPropertiesNV - { - PhysicalDeviceRayTracingPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceRayTracingPropertiesNV() + PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = 0, + uint32_t maxRecursionDepth_ = 0, + uint32_t maxShaderGroupStride_ = 0, + uint32_t shaderGroupBaseAlignment_ = 0, + uint64_t maxGeometryCount_ = 0, + uint64_t maxInstanceCount_ = 0, + uint64_t maxTriangleCount_ = 0, + uint32_t maxDescriptorSetAccelerationStructures_ = 0 ) VULKAN_HPP_NOEXCEPT + : shaderGroupHandleSize( shaderGroupHandleSize_ ) + , maxRecursionDepth( maxRecursionDepth_ ) + , maxShaderGroupStride( maxShaderGroupStride_ ) + , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ ) + , maxGeometryCount( maxGeometryCount_ ) + , maxInstanceCount( maxInstanceCount_ ) + , maxTriangleCount( maxTriangleCount_ ) + , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ ) {} + vk::PhysicalDeviceRayTracingPropertiesNV & operator=( vk::PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceRayTracingPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceRayTracingPropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceRayTracingPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50721,53 +46253,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceRayTracingPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; + void* pNext = nullptr; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; }; static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 ) VULKAN_HPP_NOEXCEPT - : representativeFragmentTest( representativeFragmentTest_ ) - {} - - PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; - void* pNext = nullptr; - vk::Bool32 representativeFragmentTest; - }; - static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV : public layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV + struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( representativeFragmentTest_ ) + : representativeFragmentTest( representativeFragmentTest_ ) {} + vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=( vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50805,56 +46325,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; + void* pNext = nullptr; + vk::Bool32 representativeFragmentTest; }; static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceSampleLocationsPropertiesEXT { - struct PhysicalDeviceSampleLocationsPropertiesEXT + PhysicalDeviceSampleLocationsPropertiesEXT( vk::SampleCountFlags sampleLocationSampleCounts_ = vk::SampleCountFlags(), + vk::Extent2D maxSampleLocationGridSize_ = vk::Extent2D(), + std::array const& sampleLocationCoordinateRange_ = { { 0 } }, + uint32_t sampleLocationSubPixelBits_ = 0, + vk::Bool32 variableSampleLocations_ = 0 ) VULKAN_HPP_NOEXCEPT + : sampleLocationSampleCounts( sampleLocationSampleCounts_ ) + , maxSampleLocationGridSize( maxSampleLocationGridSize_ ) + , sampleLocationCoordinateRange{} + , sampleLocationSubPixelBits( sampleLocationSubPixelBits_ ) + , variableSampleLocations( variableSampleLocations_ ) { - protected: - PhysicalDeviceSampleLocationsPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( sampleLocationCoordinateRange, sampleLocationCoordinateRange_ ); + } - PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; - void* pNext = nullptr; - vk::SampleCountFlags sampleLocationSampleCounts; - vk::Extent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - vk::Bool32 variableSampleLocations; - }; - static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSampleLocationsPropertiesEXT : public layout::PhysicalDeviceSampleLocationsPropertiesEXT - { - PhysicalDeviceSampleLocationsPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSampleLocationsPropertiesEXT() - {} + vk::PhysicalDeviceSampleLocationsPropertiesEXT & operator=( vk::PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSampleLocationsPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSampleLocationsPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSampleLocationsPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50884,53 +46392,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSampleLocationsPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; + void* pNext = nullptr; + vk::SampleCountFlags sampleLocationSampleCounts; + vk::Extent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + vk::Bool32 variableSampleLocations; }; static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { - struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT - { - protected: - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT; - void* pNext = nullptr; - vk::Bool32 filterMinmaxSingleComponentFormats; - vk::Bool32 filterMinmaxImageComponentMapping; - }; - static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT : public layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT - { - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() + PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( vk::Bool32 filterMinmaxSingleComponentFormats_ = 0, + vk::Bool32 filterMinmaxImageComponentMapping_ = 0 ) VULKAN_HPP_NOEXCEPT + : filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ ) + , filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ ) {} + vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT & operator=( vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50957,53 +46452,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + void* pNext = nullptr; + vk::Bool32 filterMinmaxSingleComponentFormats; + vk::Bool32 filterMinmaxImageComponentMapping; }; static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSamplerYcbcrConversionFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 ) VULKAN_HPP_NOEXCEPT - : samplerYcbcrConversion( samplerYcbcrConversion_ ) - {} - - PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; - void* pNext = nullptr; - vk::Bool32 samplerYcbcrConversion; - }; - static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSamplerYcbcrConversionFeatures : public layout::PhysicalDeviceSamplerYcbcrConversionFeatures + struct PhysicalDeviceSamplerYcbcrConversionFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( samplerYcbcrConversion_ ) + : samplerYcbcrConversion( samplerYcbcrConversion_ ) {} + vk::PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( vk::PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSamplerYcbcrConversionFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSamplerYcbcrConversionFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51041,53 +46518,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSamplerYcbcrConversionFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; + void* pNext = nullptr; + vk::Bool32 samplerYcbcrConversion; }; static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceScalarBlockLayoutFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 ) VULKAN_HPP_NOEXCEPT - : scalarBlockLayout( scalarBlockLayout_ ) - {} - - PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 scalarBlockLayout; - }; - static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceScalarBlockLayoutFeaturesEXT : public layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT + struct PhysicalDeviceScalarBlockLayoutFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( scalarBlockLayout_ ) + : scalarBlockLayout( scalarBlockLayout_ ) {} + vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT & operator=( vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51125,57 +46583,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 scalarBlockLayout; }; static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderAtomicInt64FeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0, - vk::Bool32 shaderSharedInt64Atomics_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ ) - , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ ) - {} - - PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR; - void* pNext = nullptr; - vk::Bool32 shaderBufferInt64Atomics; - vk::Bool32 shaderSharedInt64Atomics; - }; - static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderAtomicInt64FeaturesKHR : public layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR + struct PhysicalDeviceShaderAtomicInt64FeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0, vk::Bool32 shaderSharedInt64Atomics_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( shaderBufferInt64Atomics_, shaderSharedInt64Atomics_ ) + : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ ) + , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ ) {} + vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR & operator=( vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51220,57 +46657,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR; + void* pNext = nullptr; + vk::Bool32 shaderBufferInt64Atomics; + vk::Bool32 shaderSharedInt64Atomics; }; static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderClockFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( vk::Bool32 shaderSubgroupClock_ = 0, - vk::Bool32 shaderDeviceClock_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderSubgroupClock( shaderSubgroupClock_ ) - , shaderDeviceClock( shaderDeviceClock_ ) - {} - - PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 shaderSubgroupClock; - vk::Bool32 shaderDeviceClock; - }; - static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderClockFeaturesKHR : public layout::PhysicalDeviceShaderClockFeaturesKHR + struct PhysicalDeviceShaderClockFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( vk::Bool32 shaderSubgroupClock_ = 0, vk::Bool32 shaderDeviceClock_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderClockFeaturesKHR( shaderSubgroupClock_, shaderDeviceClock_ ) + : shaderSubgroupClock( shaderSubgroupClock_ ) + , shaderDeviceClock( shaderDeviceClock_ ) {} + vk::PhysicalDeviceShaderClockFeaturesKHR & operator=( vk::PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderClockFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderClockFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderClockFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51315,53 +46732,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderClockFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 shaderSubgroupClock; + vk::Bool32 shaderDeviceClock; }; static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceShaderCoreProperties2AMD { - struct PhysicalDeviceShaderCoreProperties2AMD - { - protected: - PhysicalDeviceShaderCoreProperties2AMD() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; - void* pNext = nullptr; - vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures; - uint32_t activeComputeUnitCount; - }; - static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderCoreProperties2AMD : public layout::PhysicalDeviceShaderCoreProperties2AMD - { - PhysicalDeviceShaderCoreProperties2AMD() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderCoreProperties2AMD() + PhysicalDeviceShaderCoreProperties2AMD( vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = vk::ShaderCorePropertiesFlagsAMD(), + uint32_t activeComputeUnitCount_ = 0 ) VULKAN_HPP_NOEXCEPT + : shaderCoreFeatures( shaderCoreFeatures_ ) + , activeComputeUnitCount( activeComputeUnitCount_ ) {} + vk::PhysicalDeviceShaderCoreProperties2AMD & operator=( vk::PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderCoreProperties2AMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderCoreProperties2AMD( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderCoreProperties2AMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51388,65 +46789,61 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderCoreProperties2AMD::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; + void* pNext = nullptr; + vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures; + uint32_t activeComputeUnitCount; }; static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceShaderCorePropertiesAMD { - struct PhysicalDeviceShaderCorePropertiesAMD - { - protected: - PhysicalDeviceShaderCorePropertiesAMD() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; - void* pNext = nullptr; - uint32_t shaderEngineCount; - uint32_t shaderArraysPerEngineCount; - uint32_t computeUnitsPerShaderArray; - uint32_t simdPerComputeUnit; - uint32_t wavefrontsPerSimd; - uint32_t wavefrontSize; - uint32_t sgprsPerSimd; - uint32_t minSgprAllocation; - uint32_t maxSgprAllocation; - uint32_t sgprAllocationGranularity; - uint32_t vgprsPerSimd; - uint32_t minVgprAllocation; - uint32_t maxVgprAllocation; - uint32_t vgprAllocationGranularity; - }; - static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderCorePropertiesAMD : public layout::PhysicalDeviceShaderCorePropertiesAMD - { - PhysicalDeviceShaderCorePropertiesAMD() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderCorePropertiesAMD() + PhysicalDeviceShaderCorePropertiesAMD( uint32_t shaderEngineCount_ = 0, + uint32_t shaderArraysPerEngineCount_ = 0, + uint32_t computeUnitsPerShaderArray_ = 0, + uint32_t simdPerComputeUnit_ = 0, + uint32_t wavefrontsPerSimd_ = 0, + uint32_t wavefrontSize_ = 0, + uint32_t sgprsPerSimd_ = 0, + uint32_t minSgprAllocation_ = 0, + uint32_t maxSgprAllocation_ = 0, + uint32_t sgprAllocationGranularity_ = 0, + uint32_t vgprsPerSimd_ = 0, + uint32_t minVgprAllocation_ = 0, + uint32_t maxVgprAllocation_ = 0, + uint32_t vgprAllocationGranularity_ = 0 ) VULKAN_HPP_NOEXCEPT + : shaderEngineCount( shaderEngineCount_ ) + , shaderArraysPerEngineCount( shaderArraysPerEngineCount_ ) + , computeUnitsPerShaderArray( computeUnitsPerShaderArray_ ) + , simdPerComputeUnit( simdPerComputeUnit_ ) + , wavefrontsPerSimd( wavefrontsPerSimd_ ) + , wavefrontSize( wavefrontSize_ ) + , sgprsPerSimd( sgprsPerSimd_ ) + , minSgprAllocation( minSgprAllocation_ ) + , maxSgprAllocation( maxSgprAllocation_ ) + , sgprAllocationGranularity( sgprAllocationGranularity_ ) + , vgprsPerSimd( vgprsPerSimd_ ) + , minVgprAllocation( minVgprAllocation_ ) + , maxVgprAllocation( maxVgprAllocation_ ) + , vgprAllocationGranularity( vgprAllocationGranularity_ ) {} + vk::PhysicalDeviceShaderCorePropertiesAMD & operator=( vk::PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderCorePropertiesAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderCorePropertiesAMD( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderCorePropertiesAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51485,53 +46882,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderCorePropertiesAMD::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; + void* pNext = nullptr; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; }; static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ ) - {} - - PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 shaderDemoteToHelperInvocation; - }; - static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT : public layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT + struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( shaderDemoteToHelperInvocation_ ) + : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ ) {} + vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & operator=( vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51569,53 +46960,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 shaderDemoteToHelperInvocation; }; static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderDrawParametersFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderDrawParameters( shaderDrawParameters_ ) - {} - - PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; - void* pNext = nullptr; - vk::Bool32 shaderDrawParameters; - }; - static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderDrawParametersFeatures : public layout::PhysicalDeviceShaderDrawParametersFeatures + struct PhysicalDeviceShaderDrawParametersFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderDrawParametersFeatures( shaderDrawParameters_ ) + : shaderDrawParameters( shaderDrawParameters_ ) {} + vk::PhysicalDeviceShaderDrawParametersFeatures & operator=( vk::PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderDrawParametersFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderDrawParametersFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderDrawParametersFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51653,57 +47025,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderDrawParametersFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; + void* pNext = nullptr; + vk::Bool32 shaderDrawParameters; }; static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderFloat16Int8FeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0, - vk::Bool32 shaderInt8_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderFloat16( shaderFloat16_ ) - , shaderInt8( shaderInt8_ ) - {} - - PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR; - void* pNext = nullptr; - vk::Bool32 shaderFloat16; - vk::Bool32 shaderInt8; - }; - static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderFloat16Int8FeaturesKHR : public layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR + struct PhysicalDeviceShaderFloat16Int8FeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0, vk::Bool32 shaderInt8_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( shaderFloat16_, shaderInt8_ ) + : shaderFloat16( shaderFloat16_ ) + , shaderInt8( shaderInt8_ ) {} + vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR & operator=( vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51748,53 +47099,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR; + void* pNext = nullptr; + vk::Bool32 shaderFloat16; + vk::Bool32 shaderInt8; }; static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderImageFootprintFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 ) VULKAN_HPP_NOEXCEPT - : imageFootprint( imageFootprint_ ) - {} - - PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; - void* pNext = nullptr; - vk::Bool32 imageFootprint; - }; - static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderImageFootprintFeaturesNV : public layout::PhysicalDeviceShaderImageFootprintFeaturesNV + struct PhysicalDeviceShaderImageFootprintFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( imageFootprint_ ) + : imageFootprint( imageFootprint_ ) {} + vk::PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( vk::PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderImageFootprintFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderImageFootprintFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51832,53 +47165,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderImageFootprintFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; + void* pNext = nullptr; + vk::Bool32 imageFootprint; }; static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderIntegerFunctions2( shaderIntegerFunctions2_ ) - {} - - PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - void* pNext = nullptr; - vk::Bool32 shaderIntegerFunctions2; - }; - static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : public layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL + struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( shaderIntegerFunctions2_ ) + : shaderIntegerFunctions2( shaderIntegerFunctions2_ ) {} + vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & operator=( vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51916,53 +47230,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + void* pNext = nullptr; + vk::Bool32 shaderIntegerFunctions2; }; static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderSMBuiltinsFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderSMBuiltins( shaderSMBuiltins_ ) - {} - - PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; - void* pNext = nullptr; - vk::Bool32 shaderSMBuiltins; - }; - static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderSMBuiltinsFeaturesNV : public layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV + struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( shaderSMBuiltins_ ) + : shaderSMBuiltins( shaderSMBuiltins_ ) {} + vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52000,53 +47295,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; + void* pNext = nullptr; + vk::Bool32 shaderSMBuiltins; }; static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceShaderSMBuiltinsPropertiesNV { - struct PhysicalDeviceShaderSMBuiltinsPropertiesNV - { - protected: - PhysicalDeviceShaderSMBuiltinsPropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; - void* pNext = nullptr; - uint32_t shaderSMCount; - uint32_t shaderWarpsPerSM; - }; - static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderSMBuiltinsPropertiesNV : public layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV - { - PhysicalDeviceShaderSMBuiltinsPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV() + PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = 0, + uint32_t shaderWarpsPerSM_ = 0 ) VULKAN_HPP_NOEXCEPT + : shaderSMCount( shaderSMCount_ ) + , shaderWarpsPerSM( shaderWarpsPerSM_ ) {} + vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52073,53 +47351,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; + void* pNext = nullptr; + uint32_t shaderSMCount; + uint32_t shaderWarpsPerSM; }; static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( vk::Bool32 shaderSubgroupExtendedTypes_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ ) - {} - - PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 shaderSubgroupExtendedTypes; - }; - static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR : public layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR + struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( vk::Bool32 shaderSubgroupExtendedTypes_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( shaderSubgroupExtendedTypes_ ) + : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ ) {} + vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR & operator=( vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52157,57 +47417,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 shaderSubgroupExtendedTypes; }; static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShadingRateImageFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0, - vk::Bool32 shadingRateCoarseSampleOrder_ = 0 ) VULKAN_HPP_NOEXCEPT - : shadingRateImage( shadingRateImage_ ) - , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ ) - {} - - PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; - void* pNext = nullptr; - vk::Bool32 shadingRateImage; - vk::Bool32 shadingRateCoarseSampleOrder; - }; - static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShadingRateImageFeaturesNV : public layout::PhysicalDeviceShadingRateImageFeaturesNV + struct PhysicalDeviceShadingRateImageFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0, vk::Bool32 shadingRateCoarseSampleOrder_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShadingRateImageFeaturesNV( shadingRateImage_, shadingRateCoarseSampleOrder_ ) + : shadingRateImage( shadingRateImage_ ) + , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ ) {} + vk::PhysicalDeviceShadingRateImageFeaturesNV & operator=( vk::PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShadingRateImageFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShadingRateImageFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShadingRateImageFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52252,54 +47491,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShadingRateImageFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; + void* pNext = nullptr; + vk::Bool32 shadingRateImage; + vk::Bool32 shadingRateCoarseSampleOrder; }; static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceShadingRateImagePropertiesNV { - struct PhysicalDeviceShadingRateImagePropertiesNV - { - protected: - PhysicalDeviceShadingRateImagePropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; - void* pNext = nullptr; - vk::Extent2D shadingRateTexelSize; - uint32_t shadingRatePaletteSize; - uint32_t shadingRateMaxCoarseSamples; - }; - static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShadingRateImagePropertiesNV : public layout::PhysicalDeviceShadingRateImagePropertiesNV - { - PhysicalDeviceShadingRateImagePropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShadingRateImagePropertiesNV() + PhysicalDeviceShadingRateImagePropertiesNV( vk::Extent2D shadingRateTexelSize_ = vk::Extent2D(), + uint32_t shadingRatePaletteSize_ = 0, + uint32_t shadingRateMaxCoarseSamples_ = 0 ) VULKAN_HPP_NOEXCEPT + : shadingRateTexelSize( shadingRateTexelSize_ ) + , shadingRatePaletteSize( shadingRatePaletteSize_ ) + , shadingRateMaxCoarseSamples( shadingRateMaxCoarseSamples_ ) {} + vk::PhysicalDeviceShadingRateImagePropertiesNV & operator=( vk::PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShadingRateImagePropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShadingRateImagePropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShadingRateImagePropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52327,69 +47551,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShadingRateImagePropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; + void* pNext = nullptr; + vk::Extent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; }; static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSparseImageFormatInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined, - vk::ImageType type_ = vk::ImageType::e1D, - vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1, - vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), - vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal ) VULKAN_HPP_NOEXCEPT - : format( format_ ) - , type( type_ ) - , samples( samples_ ) - , usage( usage_ ) - , tiling( tiling_ ) - {} - - PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; - const void* pNext = nullptr; - vk::Format format; - vk::ImageType type; - vk::SampleCountFlagBits samples; - vk::ImageUsageFlags usage; - vk::ImageTiling tiling; - }; - static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSparseImageFormatInfo2 : public layout::PhysicalDeviceSparseImageFormatInfo2 + struct PhysicalDeviceSparseImageFormatInfo2 { VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined, vk::ImageType type_ = vk::ImageType::e1D, vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1, vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSparseImageFormatInfo2( format_, type_, samples_, usage_, tiling_ ) + : format( format_ ) + , type( type_ ) + , samples( samples_ ) + , usage( usage_ ) + , tiling( tiling_ ) {} + vk::PhysicalDeviceSparseImageFormatInfo2 & operator=( vk::PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSparseImageFormatInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSparseImageFormatInfo2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSparseImageFormatInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52455,55 +47654,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSparseImageFormatInfo2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; + const void* pNext = nullptr; + vk::Format format; + vk::ImageType type; + vk::SampleCountFlagBits samples; + vk::ImageUsageFlags usage; + vk::ImageTiling tiling; }; static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceSubgroupProperties { - struct PhysicalDeviceSubgroupProperties - { - protected: - PhysicalDeviceSubgroupProperties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; - void* pNext = nullptr; - uint32_t subgroupSize; - vk::ShaderStageFlags supportedStages; - vk::SubgroupFeatureFlags supportedOperations; - vk::Bool32 quadOperationsInAllStages; - }; - static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSubgroupProperties : public layout::PhysicalDeviceSubgroupProperties - { - PhysicalDeviceSubgroupProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupProperties() + PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = 0, + vk::ShaderStageFlags supportedStages_ = vk::ShaderStageFlags(), + vk::SubgroupFeatureFlags supportedOperations_ = vk::SubgroupFeatureFlags(), + vk::Bool32 quadOperationsInAllStages_ = 0 ) VULKAN_HPP_NOEXCEPT + : subgroupSize( subgroupSize_ ) + , supportedStages( supportedStages_ ) + , supportedOperations( supportedOperations_ ) + , quadOperationsInAllStages( quadOperationsInAllStages_ ) {} + vk::PhysicalDeviceSubgroupProperties & operator=( vk::PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSubgroupProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52532,57 +47720,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSubgroupProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; + void* pNext = nullptr; + uint32_t subgroupSize; + vk::ShaderStageFlags supportedStages; + vk::SubgroupFeatureFlags supportedOperations; + vk::Bool32 quadOperationsInAllStages; }; static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSubgroupSizeControlFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0, - vk::Bool32 computeFullSubgroups_ = 0 ) VULKAN_HPP_NOEXCEPT - : subgroupSizeControl( subgroupSizeControl_ ) - , computeFullSubgroups( computeFullSubgroups_ ) - {} - - PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 subgroupSizeControl; - vk::Bool32 computeFullSubgroups; - }; - static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSubgroupSizeControlFeaturesEXT : public layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT + struct PhysicalDeviceSubgroupSizeControlFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0, vk::Bool32 computeFullSubgroups_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( subgroupSizeControl_, computeFullSubgroups_ ) + : subgroupSizeControl( subgroupSizeControl_ ) + , computeFullSubgroups( computeFullSubgroups_ ) {} + vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT & operator=( vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52627,55 +47797,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 subgroupSizeControl; + vk::Bool32 computeFullSubgroups; }; static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceSubgroupSizeControlPropertiesEXT { - struct PhysicalDeviceSubgroupSizeControlPropertiesEXT - { - protected: - PhysicalDeviceSubgroupSizeControlPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT; - void* pNext = nullptr; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - vk::ShaderStageFlags requiredSubgroupSizeStages; - }; - static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSubgroupSizeControlPropertiesEXT : public layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT - { - PhysicalDeviceSubgroupSizeControlPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT() + PhysicalDeviceSubgroupSizeControlPropertiesEXT( uint32_t minSubgroupSize_ = 0, + uint32_t maxSubgroupSize_ = 0, + uint32_t maxComputeWorkgroupSubgroups_ = 0, + vk::ShaderStageFlags requiredSubgroupSizeStages_ = vk::ShaderStageFlags() ) VULKAN_HPP_NOEXCEPT + : minSubgroupSize( minSubgroupSize_ ) + , maxSubgroupSize( maxSubgroupSize_ ) + , maxComputeWorkgroupSubgroups( maxComputeWorkgroupSubgroups_ ) + , requiredSubgroupSizeStages( requiredSubgroupSizeStages_ ) {} + vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT & operator=( vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52704,53 +47860,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT; + void* pNext = nullptr; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + vk::ShaderStageFlags requiredSubgroupSizeStages; }; static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSurfaceInfo2KHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() ) VULKAN_HPP_NOEXCEPT - : surface( surface_ ) - {} - - PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; - const void* pNext = nullptr; - vk::SurfaceKHR surface; - }; - static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSurfaceInfo2KHR : public layout::PhysicalDeviceSurfaceInfo2KHR + struct PhysicalDeviceSurfaceInfo2KHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSurfaceInfo2KHR( surface_ ) + : surface( surface_ ) {} + vk::PhysicalDeviceSurfaceInfo2KHR & operator=( vk::PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSurfaceInfo2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSurfaceInfo2KHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSurfaceInfo2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52788,53 +47928,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSurfaceInfo2KHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; + const void* pNext = nullptr; + vk::SurfaceKHR surface; }; static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT - : texelBufferAlignment( texelBufferAlignment_ ) - {} - - PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 texelBufferAlignment; - }; - static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT : public layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT + struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( texelBufferAlignment_ ) + : texelBufferAlignment( texelBufferAlignment_ ) {} + vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52872,55 +47993,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 texelBufferAlignment; }; static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT { - struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT - { - protected: - PhysicalDeviceTexelBufferAlignmentPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT; - void* pNext = nullptr; - vk::DeviceSize storageTexelBufferOffsetAlignmentBytes; - vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment; - vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes; - vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment; - }; - static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT : public layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT - { - PhysicalDeviceTexelBufferAlignmentPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT() + PhysicalDeviceTexelBufferAlignmentPropertiesEXT( vk::DeviceSize storageTexelBufferOffsetAlignmentBytes_ = 0, + vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = 0, + vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = 0, + vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT + : storageTexelBufferOffsetAlignmentBytes( storageTexelBufferOffsetAlignmentBytes_ ) + , storageTexelBufferOffsetSingleTexelAlignment( storageTexelBufferOffsetSingleTexelAlignment_ ) + , uniformTexelBufferOffsetAlignmentBytes( uniformTexelBufferOffsetAlignmentBytes_ ) + , uniformTexelBufferOffsetSingleTexelAlignment( uniformTexelBufferOffsetSingleTexelAlignment_ ) {} + vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT & operator=( vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52949,53 +48055,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT; + void* pNext = nullptr; + vk::DeviceSize storageTexelBufferOffsetAlignmentBytes; + vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment; + vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes; + vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment; }; static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 ) VULKAN_HPP_NOEXCEPT - : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ ) - {} - - PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT; - const void* pNext = nullptr; - vk::Bool32 textureCompressionASTC_HDR; - }; - static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT : public layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT + struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( textureCompressionASTC_HDR_ ) + : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ ) {} + vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & operator=( vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53033,53 +48123,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT; + const void* pNext = nullptr; + vk::Bool32 textureCompressionASTC_HDR; }; static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceTimelineSemaphoreFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeaturesKHR( vk::Bool32 timelineSemaphore_ = 0 ) VULKAN_HPP_NOEXCEPT - : timelineSemaphore( timelineSemaphore_ ) - {} - - PhysicalDeviceTimelineSemaphoreFeaturesKHR( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 timelineSemaphore; - }; - static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeaturesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTimelineSemaphoreFeaturesKHR : public layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR + struct PhysicalDeviceTimelineSemaphoreFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeaturesKHR( vk::Bool32 timelineSemaphore_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR( timelineSemaphore_ ) + : timelineSemaphore( timelineSemaphore_ ) {} + vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR & operator=( vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTimelineSemaphoreFeaturesKHR( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53117,52 +48188,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 timelineSemaphore; }; static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeaturesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceTimelineSemaphorePropertiesKHR { - struct PhysicalDeviceTimelineSemaphorePropertiesKHR - { - protected: - PhysicalDeviceTimelineSemaphorePropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceTimelineSemaphorePropertiesKHR( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphorePropertiesKHR; - void* pNext = nullptr; - uint64_t maxTimelineSemaphoreValueDifference; - }; - static_assert( sizeof( PhysicalDeviceTimelineSemaphorePropertiesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphorePropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTimelineSemaphorePropertiesKHR : public layout::PhysicalDeviceTimelineSemaphorePropertiesKHR - { - PhysicalDeviceTimelineSemaphorePropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTimelineSemaphorePropertiesKHR() + PhysicalDeviceTimelineSemaphorePropertiesKHR( uint64_t maxTimelineSemaphoreValueDifference_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ ) {} + vk::PhysicalDeviceTimelineSemaphorePropertiesKHR & operator=( vk::PhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTimelineSemaphorePropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTimelineSemaphorePropertiesKHR( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTimelineSemaphorePropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTimelineSemaphorePropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53188,57 +48241,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTimelineSemaphorePropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphorePropertiesKHR; + void* pNext = nullptr; + uint64_t maxTimelineSemaphoreValueDifference; }; static_assert( sizeof( PhysicalDeviceTimelineSemaphorePropertiesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphorePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceTransformFeedbackFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0, - vk::Bool32 geometryStreams_ = 0 ) VULKAN_HPP_NOEXCEPT - : transformFeedback( transformFeedback_ ) - , geometryStreams( geometryStreams_ ) - {} - - PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 transformFeedback; - vk::Bool32 geometryStreams; - }; - static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTransformFeedbackFeaturesEXT : public layout::PhysicalDeviceTransformFeedbackFeaturesEXT + struct PhysicalDeviceTransformFeedbackFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0, vk::Bool32 geometryStreams_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( transformFeedback_, geometryStreams_ ) + : transformFeedback( transformFeedback_ ) + , geometryStreams( geometryStreams_ ) {} + vk::PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( vk::PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTransformFeedbackFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTransformFeedbackFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53283,61 +48315,53 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTransformFeedbackFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 transformFeedback; + vk::Bool32 geometryStreams; }; static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceTransformFeedbackPropertiesEXT { - struct PhysicalDeviceTransformFeedbackPropertiesEXT - { - protected: - PhysicalDeviceTransformFeedbackPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; - void* pNext = nullptr; - uint32_t maxTransformFeedbackStreams; - uint32_t maxTransformFeedbackBuffers; - vk::DeviceSize maxTransformFeedbackBufferSize; - uint32_t maxTransformFeedbackStreamDataSize; - uint32_t maxTransformFeedbackBufferDataSize; - uint32_t maxTransformFeedbackBufferDataStride; - vk::Bool32 transformFeedbackQueries; - vk::Bool32 transformFeedbackStreamsLinesTriangles; - vk::Bool32 transformFeedbackRasterizationStreamSelect; - vk::Bool32 transformFeedbackDraw; - }; - static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTransformFeedbackPropertiesEXT : public layout::PhysicalDeviceTransformFeedbackPropertiesEXT - { - PhysicalDeviceTransformFeedbackPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTransformFeedbackPropertiesEXT() + PhysicalDeviceTransformFeedbackPropertiesEXT( uint32_t maxTransformFeedbackStreams_ = 0, + uint32_t maxTransformFeedbackBuffers_ = 0, + vk::DeviceSize maxTransformFeedbackBufferSize_ = 0, + uint32_t maxTransformFeedbackStreamDataSize_ = 0, + uint32_t maxTransformFeedbackBufferDataSize_ = 0, + uint32_t maxTransformFeedbackBufferDataStride_ = 0, + vk::Bool32 transformFeedbackQueries_ = 0, + vk::Bool32 transformFeedbackStreamsLinesTriangles_ = 0, + vk::Bool32 transformFeedbackRasterizationStreamSelect_ = 0, + vk::Bool32 transformFeedbackDraw_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxTransformFeedbackStreams( maxTransformFeedbackStreams_ ) + , maxTransformFeedbackBuffers( maxTransformFeedbackBuffers_ ) + , maxTransformFeedbackBufferSize( maxTransformFeedbackBufferSize_ ) + , maxTransformFeedbackStreamDataSize( maxTransformFeedbackStreamDataSize_ ) + , maxTransformFeedbackBufferDataSize( maxTransformFeedbackBufferDataSize_ ) + , maxTransformFeedbackBufferDataStride( maxTransformFeedbackBufferDataStride_ ) + , transformFeedbackQueries( transformFeedbackQueries_ ) + , transformFeedbackStreamsLinesTriangles( transformFeedbackStreamsLinesTriangles_ ) + , transformFeedbackRasterizationStreamSelect( transformFeedbackRasterizationStreamSelect_ ) + , transformFeedbackDraw( transformFeedbackDraw_ ) {} + vk::PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( vk::PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTransformFeedbackPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTransformFeedbackPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTransformFeedbackPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53372,53 +48396,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTransformFeedbackPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; + void* pNext = nullptr; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + vk::DeviceSize maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + vk::Bool32 transformFeedbackQueries; + vk::Bool32 transformFeedbackStreamsLinesTriangles; + vk::Bool32 transformFeedbackRasterizationStreamSelect; + vk::Bool32 transformFeedbackDraw; }; static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 ) VULKAN_HPP_NOEXCEPT - : uniformBufferStandardLayout( uniformBufferStandardLayout_ ) - {} - - PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 uniformBufferStandardLayout; - }; - static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR : public layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR + struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( uniformBufferStandardLayout_ ) + : uniformBufferStandardLayout( uniformBufferStandardLayout_ ) {} + vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & operator=( vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53456,57 +48470,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 uniformBufferStandardLayout; }; static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceVariablePointersFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0, - vk::Bool32 variablePointers_ = 0 ) VULKAN_HPP_NOEXCEPT - : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) - , variablePointers( variablePointers_ ) - {} - - PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures; - void* pNext = nullptr; - vk::Bool32 variablePointersStorageBuffer; - vk::Bool32 variablePointers; - }; - static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceVariablePointersFeatures : public layout::PhysicalDeviceVariablePointersFeatures + struct PhysicalDeviceVariablePointersFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0, vk::Bool32 variablePointers_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVariablePointersFeatures( variablePointersStorageBuffer_, variablePointers_ ) + : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) + , variablePointers( variablePointers_ ) {} + vk::PhysicalDeviceVariablePointersFeatures & operator=( vk::PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVariablePointersFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVariablePointersFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceVariablePointersFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53551,57 +48544,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceVariablePointersFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures; + void* pNext = nullptr; + vk::Bool32 variablePointersStorageBuffer; + vk::Bool32 variablePointers; }; static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0, - vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT - : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ ) - , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ ) - {} - - PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 vertexAttributeInstanceRateDivisor; - vk::Bool32 vertexAttributeInstanceRateZeroDivisor; - }; - static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT : public layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT + struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0, vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vertexAttributeInstanceRateDivisor_, vertexAttributeInstanceRateZeroDivisor_ ) + : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ ) + , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ ) {} + vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT & operator=( vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53646,52 +48619,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 vertexAttributeInstanceRateDivisor; + vk::Bool32 vertexAttributeInstanceRateZeroDivisor; }; static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { - struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT - { - protected: - PhysicalDeviceVertexAttributeDivisorPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; - void* pNext = nullptr; - uint32_t maxVertexAttribDivisor; - }; - static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT : public layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT - { - PhysicalDeviceVertexAttributeDivisorPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT() + PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxVertexAttribDivisor( maxVertexAttribDivisor_ ) {} + vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=( vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53717,61 +48673,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; + void* pNext = nullptr; + uint32_t maxVertexAttribDivisor; }; static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceVulkanMemoryModelFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0, - vk::Bool32 vulkanMemoryModelDeviceScope_ = 0, - vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 ) VULKAN_HPP_NOEXCEPT - : vulkanMemoryModel( vulkanMemoryModel_ ) - , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ ) - , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ ) - {} - - PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 vulkanMemoryModel; - vk::Bool32 vulkanMemoryModelDeviceScope; - vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains; - }; - static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceVulkanMemoryModelFeaturesKHR : public layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR + struct PhysicalDeviceVulkanMemoryModelFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0, vk::Bool32 vulkanMemoryModelDeviceScope_ = 0, vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( vulkanMemoryModel_, vulkanMemoryModelDeviceScope_, vulkanMemoryModelAvailabilityVisibilityChains_ ) + : vulkanMemoryModel( vulkanMemoryModel_ ) + , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ ) + , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ ) {} + vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR & operator=( vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53823,53 +48756,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 vulkanMemoryModel; + vk::Bool32 vulkanMemoryModelDeviceScope; + vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains; }; static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceYcbcrImageArraysFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 ) VULKAN_HPP_NOEXCEPT - : ycbcrImageArrays( ycbcrImageArrays_ ) - {} - - PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 ycbcrImageArrays; - }; - static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceYcbcrImageArraysFeaturesEXT : public layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT + struct PhysicalDeviceYcbcrImageArraysFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( ycbcrImageArrays_ ) + : ycbcrImageArrays( ycbcrImageArrays_ ) {} + vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53907,61 +48823,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 ycbcrImageArrays; }; static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCacheCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(), - size_t initialDataSize_ = 0, - const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , initialDataSize( initialDataSize_ ) - , pInitialData( pInitialData_ ) - {} - - PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCacheCreateInfo; - const void* pNext = nullptr; - vk::PipelineCacheCreateFlags flags; - size_t initialDataSize; - const void* pInitialData; - }; - static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCacheCreateInfo : public layout::PipelineCacheCreateInfo + struct PipelineCacheCreateInfo { VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCacheCreateInfo( flags_, initialDataSize_, pInitialData_ ) + : flags( flags_ ) + , initialDataSize( initialDataSize_ ) + , pInitialData( pInitialData_ ) {} + vk::PipelineCacheCreateInfo & operator=( vk::PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCacheCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCacheCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCacheCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54013,61 +48906,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCacheCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCacheCreateInfo; + const void* pNext = nullptr; + vk::PipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; }; static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineColorBlendAdvancedStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0, - vk::Bool32 dstPremultiplied_ = 0, - vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated ) VULKAN_HPP_NOEXCEPT - : srcPremultiplied( srcPremultiplied_ ) - , dstPremultiplied( dstPremultiplied_ ) - , blendOverlap( blendOverlap_ ) - {} - - PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; - const void* pNext = nullptr; - vk::Bool32 srcPremultiplied; - vk::Bool32 dstPremultiplied; - vk::BlendOverlapEXT blendOverlap; - }; - static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineColorBlendAdvancedStateCreateInfoEXT : public layout::PipelineColorBlendAdvancedStateCreateInfoEXT + struct PipelineColorBlendAdvancedStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0, vk::Bool32 dstPremultiplied_ = 0, vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated ) VULKAN_HPP_NOEXCEPT - : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( srcPremultiplied_, dstPremultiplied_, blendOverlap_ ) + : srcPremultiplied( srcPremultiplied_ ) + , dstPremultiplied( dstPremultiplied_ ) + , blendOverlap( blendOverlap_ ) {} + vk::PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( vk::PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineColorBlendAdvancedStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineColorBlendAdvancedStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54119,53 +48991,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineColorBlendAdvancedStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; + const void* pNext = nullptr; + vk::Bool32 srcPremultiplied; + vk::Bool32 dstPremultiplied; + vk::BlendOverlapEXT blendOverlap; }; static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCompilerControlCreateInfoAMD - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() ) VULKAN_HPP_NOEXCEPT - : compilerControlFlags( compilerControlFlags_ ) - {} - - PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD; - const void* pNext = nullptr; - vk::PipelineCompilerControlFlagsAMD compilerControlFlags; - }; - static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCompilerControlCreateInfoAMD : public layout::PipelineCompilerControlCreateInfoAMD + struct PipelineCompilerControlCreateInfoAMD { VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCompilerControlCreateInfoAMD( compilerControlFlags_ ) + : compilerControlFlags( compilerControlFlags_ ) {} + vk::PipelineCompilerControlCreateInfoAMD & operator=( vk::PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCompilerControlCreateInfoAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCompilerControlCreateInfoAMD( rhs ) - {} + { + *this = rhs; + } PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCompilerControlCreateInfoAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54203,69 +49058,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCompilerControlCreateInfoAMD::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD; + const void* pNext = nullptr; + vk::PipelineCompilerControlFlagsAMD compilerControlFlags; }; static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCoverageModulationStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(), - vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone, - vk::Bool32 coverageModulationTableEnable_ = 0, - uint32_t coverageModulationTableCount_ = 0, - const float* pCoverageModulationTable_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , coverageModulationMode( coverageModulationMode_ ) - , coverageModulationTableEnable( coverageModulationTableEnable_ ) - , coverageModulationTableCount( coverageModulationTableCount_ ) - , pCoverageModulationTable( pCoverageModulationTable_ ) - {} - - PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineCoverageModulationStateCreateFlagsNV flags; - vk::CoverageModulationModeNV coverageModulationMode; - vk::Bool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - const float* pCoverageModulationTable; - }; - static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCoverageModulationStateCreateInfoNV : public layout::PipelineCoverageModulationStateCreateInfoNV + struct PipelineCoverageModulationStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(), vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone, vk::Bool32 coverageModulationTableEnable_ = 0, uint32_t coverageModulationTableCount_ = 0, const float* pCoverageModulationTable_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageModulationStateCreateInfoNV( flags_, coverageModulationMode_, coverageModulationTableEnable_, coverageModulationTableCount_, pCoverageModulationTable_ ) + : flags( flags_ ) + , coverageModulationMode( coverageModulationMode_ ) + , coverageModulationTableEnable( coverageModulationTableEnable_ ) + , coverageModulationTableCount( coverageModulationTableCount_ ) + , pCoverageModulationTable( pCoverageModulationTable_ ) {} + vk::PipelineCoverageModulationStateCreateInfoNV & operator=( vk::PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageModulationStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageModulationStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCoverageModulationStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54331,57 +49159,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCoverageModulationStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineCoverageModulationStateCreateFlagsNV flags; + vk::CoverageModulationModeNV coverageModulationMode; + vk::Bool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; }; static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCoverageReductionStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(), - vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , coverageReductionMode( coverageReductionMode_ ) - {} - - PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineCoverageReductionStateCreateFlagsNV flags; - vk::CoverageReductionModeNV coverageReductionMode; - }; - static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCoverageReductionStateCreateInfoNV : public layout::PipelineCoverageReductionStateCreateInfoNV + struct PipelineCoverageReductionStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(), vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageReductionStateCreateInfoNV( flags_, coverageReductionMode_ ) + : flags( flags_ ) + , coverageReductionMode( coverageReductionMode_ ) {} + vk::PipelineCoverageReductionStateCreateInfoNV & operator=( vk::PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageReductionStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageReductionStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCoverageReductionStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54426,61 +49237,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCoverageReductionStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineCoverageReductionStateCreateFlagsNV flags; + vk::CoverageReductionModeNV coverageReductionMode; }; static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCoverageToColorStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(), - vk::Bool32 coverageToColorEnable_ = 0, - uint32_t coverageToColorLocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , coverageToColorEnable( coverageToColorEnable_ ) - , coverageToColorLocation( coverageToColorLocation_ ) - {} - - PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineCoverageToColorStateCreateFlagsNV flags; - vk::Bool32 coverageToColorEnable; - uint32_t coverageToColorLocation; - }; - static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCoverageToColorStateCreateInfoNV : public layout::PipelineCoverageToColorStateCreateInfoNV + struct PipelineCoverageToColorStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(), vk::Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageToColorStateCreateInfoNV( flags_, coverageToColorEnable_, coverageToColorLocation_ ) + : flags( flags_ ) + , coverageToColorEnable( coverageToColorEnable_ ) + , coverageToColorLocation( coverageToColorLocation_ ) {} + vk::PipelineCoverageToColorStateCreateInfoNV & operator=( vk::PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageToColorStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageToColorStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCoverageToColorStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54532,25 +49321,32 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCoverageToColorStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineCoverageToColorStateCreateFlagsNV flags; + vk::Bool32 coverageToColorEnable; + uint32_t coverageToColorLocation; }; static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct PipelineCreationFeedbackEXT { - PipelineCreationFeedbackEXT() VULKAN_HPP_NOEXCEPT + PipelineCreationFeedbackEXT( vk::PipelineCreationFeedbackFlagsEXT flags_ = vk::PipelineCreationFeedbackFlagsEXT(), + uint64_t duration_ = 0 ) VULKAN_HPP_NOEXCEPT + : flags( flags_ ) + , duration( duration_ ) {} PipelineCreationFeedbackEXT( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PipelineCreationFeedbackEXT& operator=( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -54582,55 +49378,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineCreationFeedbackEXT ) == sizeof( VkPipelineCreationFeedbackEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCreationFeedbackCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr, - uint32_t pipelineStageCreationFeedbackCount_ = 0, - vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pPipelineCreationFeedback( pPipelineCreationFeedback_ ) - , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ ) - , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ ) - {} - - PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback; - uint32_t pipelineStageCreationFeedbackCount; - vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks; - }; - static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCreationFeedbackCreateInfoEXT : public layout::PipelineCreationFeedbackCreateInfoEXT + struct PipelineCreationFeedbackCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr, uint32_t pipelineStageCreationFeedbackCount_ = 0, vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCreationFeedbackCreateInfoEXT( pPipelineCreationFeedback_, pipelineStageCreationFeedbackCount_, pPipelineStageCreationFeedbacks_ ) + : pPipelineCreationFeedback( pPipelineCreationFeedback_ ) + , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ ) + , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ ) {} + vk::PipelineCreationFeedbackCreateInfoEXT & operator=( vk::PipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCreationFeedbackCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCreationFeedbackCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCreationFeedbackCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54682,65 +49453,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCreationFeedbackCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks; }; static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineDiscardRectangleStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(), - vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive, - uint32_t discardRectangleCount_ = 0, - const vk::Rect2D* pDiscardRectangles_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , discardRectangleMode( discardRectangleMode_ ) - , discardRectangleCount( discardRectangleCount_ ) - , pDiscardRectangles( pDiscardRectangles_ ) - {} - - PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineDiscardRectangleStateCreateFlagsEXT flags; - vk::DiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const vk::Rect2D* pDiscardRectangles; - }; - static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineDiscardRectangleStateCreateInfoEXT : public layout::PipelineDiscardRectangleStateCreateInfoEXT + struct PipelineDiscardRectangleStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(), vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = 0, const vk::Rect2D* pDiscardRectangles_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDiscardRectangleStateCreateInfoEXT( flags_, discardRectangleMode_, discardRectangleCount_, pDiscardRectangles_ ) + : flags( flags_ ) + , discardRectangleMode( discardRectangleMode_ ) + , discardRectangleCount( discardRectangleCount_ ) + , pDiscardRectangles( pDiscardRectangles_ ) {} + vk::PipelineDiscardRectangleStateCreateInfoEXT & operator=( vk::PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDiscardRectangleStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDiscardRectangleStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineDiscardRectangleStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54799,57 +49547,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineDiscardRectangleStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineDiscardRectangleStateCreateFlagsEXT flags; + vk::DiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const vk::Rect2D* pDiscardRectangles; }; static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineExecutableInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(), - uint32_t executableIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : pipeline( pipeline_ ) - , executableIndex( executableIndex_ ) - {} - - PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineExecutableInfoKHR; - const void* pNext = nullptr; - vk::Pipeline pipeline; - uint32_t executableIndex; - }; - static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineExecutableInfoKHR : public layout::PipelineExecutableInfoKHR + struct PipelineExecutableInfoKHR { VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(), uint32_t executableIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableInfoKHR( pipeline_, executableIndex_ ) + : pipeline( pipeline_ ) + , executableIndex( executableIndex_ ) {} + vk::PipelineExecutableInfoKHR & operator=( vk::PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableInfoKHR( rhs ) - {} + { + *this = rhs; + } PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineExecutableInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54894,72 +49624,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineExecutableInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineExecutableInfoKHR; + const void* pNext = nullptr; + vk::Pipeline pipeline; + uint32_t executableIndex; }; static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineExecutableInternalRepresentationKHR - { - protected: - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array const& name_ = { { 0 } }, - std::array const& description_ = { { 0 } }, - vk::Bool32 isText_ = 0, - size_t dataSize_ = 0, - void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : name{} - , description{} - , isText( isText_ ) - , dataSize( dataSize_ ) - , pData( pData_ ) - { - vk::ConstExpressionArrayCopy::copy( name, name_ ); - vk::ConstExpressionArrayCopy::copy( description, description_ ); - } - - PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; - void* pNext = nullptr; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - vk::Bool32 isText; - size_t dataSize; - void* pData; - }; - static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineExecutableInternalRepresentationKHR : public layout::PipelineExecutableInternalRepresentationKHR + struct PipelineExecutableInternalRepresentationKHR { VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array const& name_ = { { 0 } }, std::array const& description_ = { { 0 } }, vk::Bool32 isText_ = 0, size_t dataSize_ = 0, void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableInternalRepresentationKHR( name_, description_, isText_, dataSize_, pData_ ) - {} + : name{} + , description{} + , isText( isText_ ) + , dataSize( dataSize_ ) + , pData( pData_ ) + { + vk::ConstExpressionArrayCopy::copy( name, name_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } + + vk::PipelineExecutableInternalRepresentationKHR & operator=( vk::PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableInternalRepresentationKHR ) - sizeof( vk::StructureType ) ); + return *this; + } PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableInternalRepresentationKHR( rhs ) - {} + { + *this = rhs; + } PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineExecutableInternalRepresentationKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55025,55 +49729,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineExecutableInternalRepresentationKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; + void* pNext = nullptr; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + vk::Bool32 isText; + size_t dataSize; + void* pData; }; static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PipelineExecutablePropertiesKHR { - struct PipelineExecutablePropertiesKHR + PipelineExecutablePropertiesKHR( vk::ShaderStageFlags stages_ = vk::ShaderStageFlags(), + std::array const& name_ = { { 0 } }, + std::array const& description_ = { { 0 } }, + uint32_t subgroupSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : stages( stages_ ) + , name{} + , description{} + , subgroupSize( subgroupSize_ ) { - protected: - PipelineExecutablePropertiesKHR() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( name, name_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } - PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; - void* pNext = nullptr; - vk::ShaderStageFlags stages; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - uint32_t subgroupSize; - }; - static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineExecutablePropertiesKHR : public layout::PipelineExecutablePropertiesKHR - { - PipelineExecutablePropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutablePropertiesKHR() - {} + vk::PipelineExecutablePropertiesKHR & operator=( vk::PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutablePropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutablePropertiesKHR( rhs ) - {} + { + *this = rhs; + } PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineExecutablePropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55102,8 +49798,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineExecutablePropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; + void* pNext = nullptr; + vk::ShaderStageFlags stages; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t subgroupSize; }; static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -55133,49 +49834,35 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ }; - namespace layout + struct PipelineExecutableStatisticKHR { - struct PipelineExecutableStatisticKHR + PipelineExecutableStatisticKHR( std::array const& name_ = { { 0 } }, + std::array const& description_ = { { 0 } }, + vk::PipelineExecutableStatisticFormatKHR format_ = vk::PipelineExecutableStatisticFormatKHR::eBool32, + vk::PipelineExecutableStatisticValueKHR value_ = vk::PipelineExecutableStatisticValueKHR() ) VULKAN_HPP_NOEXCEPT + : name{} + , description{} + , format( format_ ) + , value( value_ ) { - protected: - PipelineExecutableStatisticKHR() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( name, name_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } - PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; - void* pNext = nullptr; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - vk::PipelineExecutableStatisticFormatKHR format; - vk::PipelineExecutableStatisticValueKHR value; - }; - static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineExecutableStatisticKHR : public layout::PipelineExecutableStatisticKHR - { - PipelineExecutableStatisticKHR() VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableStatisticKHR() - {} + vk::PipelineExecutableStatisticKHR & operator=( vk::PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableStatisticKHR ) - sizeof( vk::StructureType ) ); + return *this; + } PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableStatisticKHR( rhs ) - {} + { + *this = rhs; + } PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineExecutableStatisticKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55189,53 +49876,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } - private: - using layout::PipelineExecutableStatisticKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; + void* pNext = nullptr; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + vk::PipelineExecutableStatisticFormatKHR format; + vk::PipelineExecutableStatisticValueKHR value; }; static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() ) VULKAN_HPP_NOEXCEPT - : pipeline( pipeline_ ) - {} - - PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineInfoKHR; - const void* pNext = nullptr; - vk::Pipeline pipeline; - }; - static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineInfoKHR : public layout::PipelineInfoKHR + struct PipelineInfoKHR { VULKAN_HPP_CONSTEXPR PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() ) VULKAN_HPP_NOEXCEPT - : layout::PipelineInfoKHR( pipeline_ ) + : pipeline( pipeline_ ) {} + vk::PipelineInfoKHR & operator=( vk::PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineInfoKHR( rhs ) - {} + { + *this = rhs; + } PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55273,8 +49944,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineInfoKHR; + const void* pNext = nullptr; + vk::Pipeline pipeline; }; static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -55291,12 +49964,12 @@ namespace VULKAN_HPP_NAMESPACE PushConstantRange( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PushConstantRange& operator=( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -55348,63 +50021,34 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineLayoutCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(), - uint32_t setLayoutCount_ = 0, - const vk::DescriptorSetLayout* pSetLayouts_ = nullptr, - uint32_t pushConstantRangeCount_ = 0, - const vk::PushConstantRange* pPushConstantRanges_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , setLayoutCount( setLayoutCount_ ) - , pSetLayouts( pSetLayouts_ ) - , pushConstantRangeCount( pushConstantRangeCount_ ) - , pPushConstantRanges( pPushConstantRanges_ ) - {} - - PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineLayoutCreateInfo; - const void* pNext = nullptr; - vk::PipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const vk::DescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const vk::PushConstantRange* pPushConstantRanges; - }; - static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineLayoutCreateInfo : public layout::PipelineLayoutCreateInfo + struct PipelineLayoutCreateInfo { VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const vk::DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const vk::PushConstantRange* pPushConstantRanges_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineLayoutCreateInfo( flags_, setLayoutCount_, pSetLayouts_, pushConstantRangeCount_, pPushConstantRanges_ ) + : flags( flags_ ) + , setLayoutCount( setLayoutCount_ ) + , pSetLayouts( pSetLayouts_ ) + , pushConstantRangeCount( pushConstantRangeCount_ ) + , pPushConstantRanges( pPushConstantRanges_ ) {} + vk::PipelineLayoutCreateInfo & operator=( vk::PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineLayoutCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineLayoutCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineLayoutCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55470,61 +50114,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineLayoutCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineLayoutCreateInfo; + const void* pNext = nullptr; + vk::PipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const vk::DescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const vk::PushConstantRange* pPushConstantRanges; }; static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationConservativeStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(), - vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled, - float extraPrimitiveOverestimationSize_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , conservativeRasterizationMode( conservativeRasterizationMode_ ) - , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ ) - {} - - PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags; - vk::ConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; - }; - static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationConservativeStateCreateInfoEXT : public layout::PipelineRasterizationConservativeStateCreateInfoEXT + struct PipelineRasterizationConservativeStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(), vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled, float extraPrimitiveOverestimationSize_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationConservativeStateCreateInfoEXT( flags_, conservativeRasterizationMode_, extraPrimitiveOverestimationSize_ ) + : flags( flags_ ) + , conservativeRasterizationMode( conservativeRasterizationMode_ ) + , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ ) {} + vk::PipelineRasterizationConservativeStateCreateInfoEXT & operator=( vk::PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationConservativeStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationConservativeStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationConservativeStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55576,57 +50201,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationConservativeStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags; + vk::ConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; }; static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationDepthClipStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(), - vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , depthClipEnable( depthClipEnable_ ) - {} - - PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags; - vk::Bool32 depthClipEnable; - }; - static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationDepthClipStateCreateInfoEXT : public layout::PipelineRasterizationDepthClipStateCreateInfoEXT + struct PipelineRasterizationDepthClipStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(), vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( flags_, depthClipEnable_ ) + : flags( flags_ ) + , depthClipEnable( depthClipEnable_ ) {} + vk::PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( vk::PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationDepthClipStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationDepthClipStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55671,65 +50277,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationDepthClipStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags; + vk::Bool32 depthClipEnable; }; static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationLineStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault, - vk::Bool32 stippledLineEnable_ = 0, - uint32_t lineStippleFactor_ = 0, - uint16_t lineStipplePattern_ = 0 ) VULKAN_HPP_NOEXCEPT - : lineRasterizationMode( lineRasterizationMode_ ) - , stippledLineEnable( stippledLineEnable_ ) - , lineStippleFactor( lineStippleFactor_ ) - , lineStipplePattern( lineStipplePattern_ ) - {} - - PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT; - const void* pNext = nullptr; - vk::LineRasterizationModeEXT lineRasterizationMode; - vk::Bool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; - }; - static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationLineStateCreateInfoEXT : public layout::PipelineRasterizationLineStateCreateInfoEXT + struct PipelineRasterizationLineStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault, vk::Bool32 stippledLineEnable_ = 0, uint32_t lineStippleFactor_ = 0, uint16_t lineStipplePattern_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationLineStateCreateInfoEXT( lineRasterizationMode_, stippledLineEnable_, lineStippleFactor_, lineStipplePattern_ ) + : lineRasterizationMode( lineRasterizationMode_ ) + , stippledLineEnable( stippledLineEnable_ ) + , lineStippleFactor( lineStippleFactor_ ) + , lineStipplePattern( lineStipplePattern_ ) {} + vk::PipelineRasterizationLineStateCreateInfoEXT & operator=( vk::PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationLineStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationLineStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationLineStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55788,53 +50370,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationLineStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT; + const void* pNext = nullptr; + vk::LineRasterizationModeEXT lineRasterizationMode; + vk::Bool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; }; static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationStateRasterizationOrderAMD - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT - : rasterizationOrder( rasterizationOrder_ ) - {} - - PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; - const void* pNext = nullptr; - vk::RasterizationOrderAMD rasterizationOrder; - }; - static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationStateRasterizationOrderAMD : public layout::PipelineRasterizationStateRasterizationOrderAMD + struct PipelineRasterizationStateRasterizationOrderAMD { VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateRasterizationOrderAMD( rasterizationOrder_ ) + : rasterizationOrder( rasterizationOrder_ ) {} + vk::PipelineRasterizationStateRasterizationOrderAMD & operator=( vk::PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateRasterizationOrderAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateRasterizationOrderAMD( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationStateRasterizationOrderAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55872,57 +50438,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationStateRasterizationOrderAMD::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; + const void* pNext = nullptr; + vk::RasterizationOrderAMD rasterizationOrder; }; static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationStateStreamCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(), - uint32_t rasterizationStream_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , rasterizationStream( rasterizationStream_ ) - {} - - PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineRasterizationStateStreamCreateFlagsEXT flags; - uint32_t rasterizationStream; - }; - static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationStateStreamCreateInfoEXT : public layout::PipelineRasterizationStateStreamCreateInfoEXT + struct PipelineRasterizationStateStreamCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(), uint32_t rasterizationStream_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateStreamCreateInfoEXT( flags_, rasterizationStream_ ) + : flags( flags_ ) + , rasterizationStream( rasterizationStream_ ) {} + vk::PipelineRasterizationStateStreamCreateInfoEXT & operator=( vk::PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateStreamCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateStreamCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationStateStreamCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55967,53 +50512,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationStateStreamCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; }; static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRepresentativeFragmentTestStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : representativeFragmentTestEnable( representativeFragmentTestEnable_ ) - {} - - PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 representativeFragmentTestEnable; - }; - static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRepresentativeFragmentTestStateCreateInfoNV : public layout::PipelineRepresentativeFragmentTestStateCreateInfoNV + struct PipelineRepresentativeFragmentTestStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( representativeFragmentTestEnable_ ) + : representativeFragmentTestEnable( representativeFragmentTestEnable_ ) {} + vk::PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=( vk::PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRepresentativeFragmentTestStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56051,57 +50578,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 representativeFragmentTestEnable; }; static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineSampleLocationsStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0, - vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() ) VULKAN_HPP_NOEXCEPT - : sampleLocationsEnable( sampleLocationsEnable_ ) - , sampleLocationsInfo( sampleLocationsInfo_ ) - {} - - PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; - const void* pNext = nullptr; - vk::Bool32 sampleLocationsEnable; - vk::SampleLocationsInfoEXT sampleLocationsInfo; - }; - static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineSampleLocationsStateCreateInfoEXT : public layout::PipelineSampleLocationsStateCreateInfoEXT + struct PipelineSampleLocationsStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0, vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() ) VULKAN_HPP_NOEXCEPT - : layout::PipelineSampleLocationsStateCreateInfoEXT( sampleLocationsEnable_, sampleLocationsInfo_ ) + : sampleLocationsEnable( sampleLocationsEnable_ ) + , sampleLocationsInfo( sampleLocationsInfo_ ) {} + vk::PipelineSampleLocationsStateCreateInfoEXT & operator=( vk::PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineSampleLocationsStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineSampleLocationsStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineSampleLocationsStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56146,52 +50652,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineSampleLocationsStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; + const void* pNext = nullptr; + vk::Bool32 sampleLocationsEnable; + vk::SampleLocationsInfoEXT sampleLocationsInfo; }; static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { - struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT - { - protected: - PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() VULKAN_HPP_NOEXCEPT - {} - - PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; - void* pNext = nullptr; - uint32_t requiredSubgroupSize; - }; - static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT : public layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT - { - PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() VULKAN_HPP_NOEXCEPT - : layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() + PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( uint32_t requiredSubgroupSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : requiredSubgroupSize( requiredSubgroupSize_ ) {} + vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT & operator=( vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56217,53 +50706,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + void* pNext = nullptr; + uint32_t requiredSubgroupSize; }; static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineTessellationDomainOriginStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT - : domainOrigin( domainOrigin_ ) - {} - - PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; - const void* pNext = nullptr; - vk::TessellationDomainOrigin domainOrigin; - }; - static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineTessellationDomainOriginStateCreateInfo : public layout::PipelineTessellationDomainOriginStateCreateInfo + struct PipelineTessellationDomainOriginStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT - : layout::PipelineTessellationDomainOriginStateCreateInfo( domainOrigin_ ) + : domainOrigin( domainOrigin_ ) {} + vk::PipelineTessellationDomainOriginStateCreateInfo & operator=( vk::PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineTessellationDomainOriginStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineTessellationDomainOriginStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineTessellationDomainOriginStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56301,8 +50771,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineTessellationDomainOriginStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; + const void* pNext = nullptr; + vk::TessellationDomainOrigin domainOrigin; }; static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -56317,12 +50789,12 @@ namespace VULKAN_HPP_NAMESPACE VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -56366,51 +50838,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineVertexInputDivisorStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0, - const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : vertexBindingDivisorCount( vertexBindingDivisorCount_ ) - , pVertexBindingDivisors( pVertexBindingDivisors_ ) - {} - - PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; - const void* pNext = nullptr; - uint32_t vertexBindingDivisorCount; - const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; - }; - static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineVertexInputDivisorStateCreateInfoEXT : public layout::PipelineVertexInputDivisorStateCreateInfoEXT + struct PipelineVertexInputDivisorStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0, const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineVertexInputDivisorStateCreateInfoEXT( vertexBindingDivisorCount_, pVertexBindingDivisors_ ) + : vertexBindingDivisorCount( vertexBindingDivisorCount_ ) + , pVertexBindingDivisors( pVertexBindingDivisors_ ) {} + vk::PipelineVertexInputDivisorStateCreateInfoEXT & operator=( vk::PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineVertexInputDivisorStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineVertexInputDivisorStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineVertexInputDivisorStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56455,61 +50904,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineVertexInputDivisorStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; + const void* pNext = nullptr; + uint32_t vertexBindingDivisorCount; + const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; }; static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportCoarseSampleOrderStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault, - uint32_t customSampleOrderCount_ = 0, - const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr ) VULKAN_HPP_NOEXCEPT - : sampleOrderType( sampleOrderType_ ) - , customSampleOrderCount( customSampleOrderCount_ ) - , pCustomSampleOrders( pCustomSampleOrders_ ) - {} - - PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; - const void* pNext = nullptr; - vk::CoarseSampleOrderTypeNV sampleOrderType; - uint32_t customSampleOrderCount; - const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders; - }; - static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportCoarseSampleOrderStateCreateInfoNV : public layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV + struct PipelineViewportCoarseSampleOrderStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault, uint32_t customSampleOrderCount_ = 0, const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( sampleOrderType_, customSampleOrderCount_, pCustomSampleOrders_ ) + : sampleOrderType( sampleOrderType_ ) + , customSampleOrderCount( customSampleOrderCount_ ) + , pCustomSampleOrders( pCustomSampleOrders_ ) {} + vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=( vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56561,57 +50988,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; + const void* pNext = nullptr; + vk::CoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders; }; static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportExclusiveScissorStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0, - const vk::Rect2D* pExclusiveScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : exclusiveScissorCount( exclusiveScissorCount_ ) - , pExclusiveScissors( pExclusiveScissors_ ) - {} - - PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; - const void* pNext = nullptr; - uint32_t exclusiveScissorCount; - const vk::Rect2D* pExclusiveScissors; - }; - static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportExclusiveScissorStateCreateInfoNV : public layout::PipelineViewportExclusiveScissorStateCreateInfoNV + struct PipelineViewportExclusiveScissorStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0, const vk::Rect2D* pExclusiveScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( exclusiveScissorCount_, pExclusiveScissors_ ) + : exclusiveScissorCount( exclusiveScissorCount_ ) + , pExclusiveScissors( pExclusiveScissors_ ) {} + vk::PipelineViewportExclusiveScissorStateCreateInfoNV & operator=( vk::PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportExclusiveScissorStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportExclusiveScissorStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56656,8 +51064,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportExclusiveScissorStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; + const void* pNext = nullptr; + uint32_t exclusiveScissorCount; + const vk::Rect2D* pExclusiveScissors; }; static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -56672,12 +51083,12 @@ namespace VULKAN_HPP_NAMESPACE ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -56721,55 +51132,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportShadingRateImageStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0, - uint32_t viewportCount_ = 0, - const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : shadingRateImageEnable( shadingRateImageEnable_ ) - , viewportCount( viewportCount_ ) - , pShadingRatePalettes( pShadingRatePalettes_ ) - {} - - PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 shadingRateImageEnable; - uint32_t viewportCount; - const vk::ShadingRatePaletteNV* pShadingRatePalettes; - }; - static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportShadingRateImageStateCreateInfoNV : public layout::PipelineViewportShadingRateImageStateCreateInfoNV + struct PipelineViewportShadingRateImageStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0, uint32_t viewportCount_ = 0, const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportShadingRateImageStateCreateInfoNV( shadingRateImageEnable_, viewportCount_, pShadingRatePalettes_ ) + : shadingRateImageEnable( shadingRateImageEnable_ ) + , viewportCount( viewportCount_ ) + , pShadingRatePalettes( pShadingRatePalettes_ ) {} + vk::PipelineViewportShadingRateImageStateCreateInfoNV & operator=( vk::PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportShadingRateImageStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportShadingRateImageStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportShadingRateImageStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56821,8 +51207,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportShadingRateImageStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 shadingRateImageEnable; + uint32_t viewportCount; + const vk::ShadingRatePaletteNV* pShadingRatePalettes; }; static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -56841,12 +51231,12 @@ namespace VULKAN_HPP_NAMESPACE ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -56906,55 +51296,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportSwizzleStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(), - uint32_t viewportCount_ = 0, - const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , viewportCount( viewportCount_ ) - , pViewportSwizzles( pViewportSwizzles_ ) - {} - - PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - const vk::ViewportSwizzleNV* pViewportSwizzles; - }; - static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportSwizzleStateCreateInfoNV : public layout::PipelineViewportSwizzleStateCreateInfoNV + struct PipelineViewportSwizzleStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_ = 0, const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportSwizzleStateCreateInfoNV( flags_, viewportCount_, pViewportSwizzles_ ) + : flags( flags_ ) + , viewportCount( viewportCount_ ) + , pViewportSwizzles( pViewportSwizzles_ ) {} + vk::PipelineViewportSwizzleStateCreateInfoNV & operator=( vk::PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportSwizzleStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportSwizzleStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportSwizzleStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57006,8 +51371,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportSwizzleStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const vk::ViewportSwizzleNV* pViewportSwizzles; }; static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -57022,12 +51391,12 @@ namespace VULKAN_HPP_NAMESPACE ViewportWScalingNV( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57071,55 +51440,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportWScalingStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0, - uint32_t viewportCount_ = 0, - const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr ) VULKAN_HPP_NOEXCEPT - : viewportWScalingEnable( viewportWScalingEnable_ ) - , viewportCount( viewportCount_ ) - , pViewportWScalings( pViewportWScalings_ ) - {} - - PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 viewportWScalingEnable; - uint32_t viewportCount; - const vk::ViewportWScalingNV* pViewportWScalings; - }; - static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportWScalingStateCreateInfoNV : public layout::PipelineViewportWScalingStateCreateInfoNV + struct PipelineViewportWScalingStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0, uint32_t viewportCount_ = 0, const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportWScalingStateCreateInfoNV( viewportWScalingEnable_, viewportCount_, pViewportWScalings_ ) + : viewportWScalingEnable( viewportWScalingEnable_ ) + , viewportCount( viewportCount_ ) + , pViewportWScalings( pViewportWScalings_ ) {} + vk::PipelineViewportWScalingStateCreateInfoNV & operator=( vk::PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportWScalingStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportWScalingStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportWScalingStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57171,55 +51515,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportWScalingStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 viewportWScalingEnable; + uint32_t viewportCount; + const vk::ViewportWScalingNV* pViewportWScalings; }; static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_GGP - namespace layout - { - struct PresentFrameTokenGGP - { - protected: - VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 ) VULKAN_HPP_NOEXCEPT - : frameToken( frameToken_ ) - {} - - PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePresentFrameTokenGGP; - const void* pNext = nullptr; - GgpFrameToken frameToken; - }; - static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "layout struct and wrapper have different size!" ); - } - - struct PresentFrameTokenGGP : public layout::PresentFrameTokenGGP + struct PresentFrameTokenGGP { VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PresentFrameTokenGGP( frameToken_ ) + : frameToken( frameToken_ ) {} + vk::PresentFrameTokenGGP & operator=( vk::PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentFrameTokenGGP ) - sizeof( vk::StructureType ) ); + return *this; + } + PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PresentFrameTokenGGP( rhs ) - {} + { + *this = rhs; + } PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PresentFrameTokenGGP::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57257,57 +51584,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PresentFrameTokenGGP::sType; + public: + const vk::StructureType sType = StructureType::ePresentFrameTokenGGP; + const void* pNext = nullptr; + GgpFrameToken frameToken; }; static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_GGP*/ - namespace layout - { - struct PresentInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, - const vk::Semaphore* pWaitSemaphores_ = nullptr, - uint32_t swapchainCount_ = 0, - const vk::SwapchainKHR* pSwapchains_ = nullptr, - const uint32_t* pImageIndices_ = nullptr, - vk::Result* pResults_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , swapchainCount( swapchainCount_ ) - , pSwapchains( pSwapchains_ ) - , pImageIndices( pImageIndices_ ) - , pResults( pResults_ ) - {} - - PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePresentInfoKHR; - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const vk::Semaphore* pWaitSemaphores; - uint32_t swapchainCount; - const vk::SwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - vk::Result* pResults; - }; - static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct PresentInfoKHR : public layout::PresentInfoKHR + struct PresentInfoKHR { VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const vk::Semaphore* pWaitSemaphores_ = nullptr, @@ -57315,16 +51601,28 @@ namespace VULKAN_HPP_NAMESPACE const vk::SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, vk::Result* pResults_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PresentInfoKHR( waitSemaphoreCount_, pWaitSemaphores_, swapchainCount_, pSwapchains_, pImageIndices_, pResults_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , swapchainCount( swapchainCount_ ) + , pSwapchains( pSwapchains_ ) + , pImageIndices( pImageIndices_ ) + , pResults( pResults_ ) {} + vk::PresentInfoKHR & operator=( vk::PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PresentInfoKHR( rhs ) - {} + { + *this = rhs; + } PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PresentInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57397,8 +51695,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PresentInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::ePresentInfoKHR; + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const vk::Semaphore* pWaitSemaphores; + uint32_t swapchainCount; + const vk::SwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + vk::Result* pResults; }; static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -57422,12 +51727,12 @@ namespace VULKAN_HPP_NAMESPACE RectLayerKHR( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57489,12 +51794,12 @@ namespace VULKAN_HPP_NAMESPACE PresentRegionKHR( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57538,51 +51843,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PresentRegionsKHR - { - protected: - VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = 0, - const vk::PresentRegionKHR* pRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : swapchainCount( swapchainCount_ ) - , pRegions( pRegions_ ) - {} - - PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePresentRegionsKHR; - const void* pNext = nullptr; - uint32_t swapchainCount; - const vk::PresentRegionKHR* pRegions; - }; - static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "layout struct and wrapper have different size!" ); - } - - struct PresentRegionsKHR : public layout::PresentRegionsKHR + struct PresentRegionsKHR { VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = 0, const vk::PresentRegionKHR* pRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PresentRegionsKHR( swapchainCount_, pRegions_ ) + : swapchainCount( swapchainCount_ ) + , pRegions( pRegions_ ) {} + vk::PresentRegionsKHR & operator=( vk::PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentRegionsKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PresentRegionsKHR( rhs ) - {} + { + *this = rhs; + } PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PresentRegionsKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57627,8 +51909,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PresentRegionsKHR::sType; + public: + const vk::StructureType sType = StructureType::ePresentRegionsKHR; + const void* pNext = nullptr; + uint32_t swapchainCount; + const vk::PresentRegionKHR* pRegions; }; static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -57643,12 +51928,12 @@ namespace VULKAN_HPP_NAMESPACE PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57692,51 +51977,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PresentTimesInfoGOOGLE - { - protected: - VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, - const vk::PresentTimeGOOGLE* pTimes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : swapchainCount( swapchainCount_ ) - , pTimes( pTimes_ ) - {} - - PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePresentTimesInfoGOOGLE; - const void* pNext = nullptr; - uint32_t swapchainCount; - const vk::PresentTimeGOOGLE* pTimes; - }; - static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "layout struct and wrapper have different size!" ); - } - - struct PresentTimesInfoGOOGLE : public layout::PresentTimesInfoGOOGLE + struct PresentTimesInfoGOOGLE { VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, const vk::PresentTimeGOOGLE* pTimes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PresentTimesInfoGOOGLE( swapchainCount_, pTimes_ ) + : swapchainCount( swapchainCount_ ) + , pTimes( pTimes_ ) {} + vk::PresentTimesInfoGOOGLE & operator=( vk::PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentTimesInfoGOOGLE ) - sizeof( vk::StructureType ) ); + return *this; + } + PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PresentTimesInfoGOOGLE( rhs ) - {} + { + *this = rhs; + } PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PresentTimesInfoGOOGLE::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57781,53 +52043,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PresentTimesInfoGOOGLE::sType; + public: + const vk::StructureType sType = StructureType::ePresentTimesInfoGOOGLE; + const void* pNext = nullptr; + uint32_t swapchainCount; + const vk::PresentTimeGOOGLE* pTimes; }; static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ProtectedSubmitInfo - { - protected: - VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 ) VULKAN_HPP_NOEXCEPT - : protectedSubmit( protectedSubmit_ ) - {} - - ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eProtectedSubmitInfo; - const void* pNext = nullptr; - vk::Bool32 protectedSubmit; - }; - static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "layout struct and wrapper have different size!" ); - } - - struct ProtectedSubmitInfo : public layout::ProtectedSubmitInfo + struct ProtectedSubmitInfo { VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ProtectedSubmitInfo( protectedSubmit_ ) + : protectedSubmit( protectedSubmit_ ) {} + vk::ProtectedSubmitInfo & operator=( vk::ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ProtectedSubmitInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ProtectedSubmitInfo( rhs ) - {} + { + *this = rhs; + } ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ProtectedSubmitInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57865,65 +52109,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ProtectedSubmitInfo::sType; + public: + const vk::StructureType sType = StructureType::eProtectedSubmitInfo; + const void* pNext = nullptr; + vk::Bool32 protectedSubmit; }; static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct QueryPoolCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(), - vk::QueryType queryType_ = vk::QueryType::eOcclusion, - uint32_t queryCount_ = 0, - vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queryType( queryType_ ) - , queryCount( queryCount_ ) - , pipelineStatistics( pipelineStatistics_ ) - {} - - QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eQueryPoolCreateInfo; - const void* pNext = nullptr; - vk::QueryPoolCreateFlags flags; - vk::QueryType queryType; - uint32_t queryCount; - vk::QueryPipelineStatisticFlags pipelineStatistics; - }; - static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct QueryPoolCreateInfo : public layout::QueryPoolCreateInfo + struct QueryPoolCreateInfo { VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(), vk::QueryType queryType_ = vk::QueryType::eOcclusion, uint32_t queryCount_ = 0, vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT - : layout::QueryPoolCreateInfo( flags_, queryType_, queryCount_, pipelineStatistics_ ) + : flags( flags_ ) + , queryType( queryType_ ) + , queryCount( queryCount_ ) + , pipelineStatistics( pipelineStatistics_ ) {} + vk::QueryPoolCreateInfo & operator=( vk::QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::QueryPoolCreateInfo( rhs ) - {} + { + *this = rhs; + } QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::QueryPoolCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57982,53 +52201,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::QueryPoolCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eQueryPoolCreateInfo; + const void* pNext = nullptr; + vk::QueryPoolCreateFlags flags; + vk::QueryType queryType; + uint32_t queryCount; + vk::QueryPipelineStatisticFlags pipelineStatistics; }; static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct QueryPoolCreateInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT - : performanceCountersSampling( performanceCountersSampling_ ) - {} - - QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eQueryPoolCreateInfoINTEL; - const void* pNext = nullptr; - vk::QueryPoolSamplingModeINTEL performanceCountersSampling; - }; - static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct QueryPoolCreateInfoINTEL : public layout::QueryPoolCreateInfoINTEL + struct QueryPoolCreateInfoINTEL { VULKAN_HPP_CONSTEXPR QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT - : layout::QueryPoolCreateInfoINTEL( performanceCountersSampling_ ) + : performanceCountersSampling( performanceCountersSampling_ ) {} + vk::QueryPoolCreateInfoINTEL & operator=( vk::QueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolCreateInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::QueryPoolCreateInfoINTEL( rhs ) - {} + { + *this = rhs; + } QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::QueryPoolCreateInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58066,52 +52269,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::QueryPoolCreateInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::eQueryPoolCreateInfoINTEL; + const void* pNext = nullptr; + vk::QueryPoolSamplingModeINTEL performanceCountersSampling; }; static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct QueueFamilyCheckpointPropertiesNV { - struct QueueFamilyCheckpointPropertiesNV - { - protected: - QueueFamilyCheckpointPropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV; - void* pNext = nullptr; - vk::PipelineStageFlags checkpointExecutionStageMask; - }; - static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct QueueFamilyCheckpointPropertiesNV : public layout::QueueFamilyCheckpointPropertiesNV - { - QueueFamilyCheckpointPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::QueueFamilyCheckpointPropertiesNV() + QueueFamilyCheckpointPropertiesNV( vk::PipelineStageFlags checkpointExecutionStageMask_ = vk::PipelineStageFlags() ) VULKAN_HPP_NOEXCEPT + : checkpointExecutionStageMask( checkpointExecutionStageMask_ ) {} + vk::QueueFamilyCheckpointPropertiesNV & operator=( vk::QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueueFamilyCheckpointPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::QueueFamilyCheckpointPropertiesNV( rhs ) - {} + { + *this = rhs; + } QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::QueueFamilyCheckpointPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58137,25 +52322,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::QueueFamilyCheckpointPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV; + void* pNext = nullptr; + vk::PipelineStageFlags checkpointExecutionStageMask; }; static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct QueueFamilyProperties { - QueueFamilyProperties() VULKAN_HPP_NOEXCEPT + QueueFamilyProperties( vk::QueueFlags queueFlags_ = vk::QueueFlags(), + uint32_t queueCount_ = 0, + uint32_t timestampValidBits_ = 0, + vk::Extent3D minImageTransferGranularity_ = vk::Extent3D() ) VULKAN_HPP_NOEXCEPT + : queueFlags( queueFlags_ ) + , queueCount( queueCount_ ) + , timestampValidBits( timestampValidBits_ ) + , minImageTransferGranularity( minImageTransferGranularity_ ) {} QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } QueueFamilyProperties& operator=( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -58191,46 +52385,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct QueueFamilyProperties2 { - struct QueueFamilyProperties2 - { - protected: - QueueFamilyProperties2() VULKAN_HPP_NOEXCEPT - {} - - QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eQueueFamilyProperties2; - void* pNext = nullptr; - vk::QueueFamilyProperties queueFamilyProperties; - }; - static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct QueueFamilyProperties2 : public layout::QueueFamilyProperties2 - { - QueueFamilyProperties2() VULKAN_HPP_NOEXCEPT - : layout::QueueFamilyProperties2() + QueueFamilyProperties2( vk::QueueFamilyProperties queueFamilyProperties_ = vk::QueueFamilyProperties() ) VULKAN_HPP_NOEXCEPT + : queueFamilyProperties( queueFamilyProperties_ ) {} + vk::QueueFamilyProperties2 & operator=( vk::QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueueFamilyProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::QueueFamilyProperties2( rhs ) - {} + { + *this = rhs; + } QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::QueueFamilyProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58256,69 +52430,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::QueueFamilyProperties2::sType; + public: + const vk::StructureType sType = StructureType::eQueueFamilyProperties2; + void* pNext = nullptr; + vk::QueueFamilyProperties queueFamilyProperties; }; static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RayTracingShaderGroupCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral, - uint32_t generalShader_ = 0, - uint32_t closestHitShader_ = 0, - uint32_t anyHitShader_ = 0, - uint32_t intersectionShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - , generalShader( generalShader_ ) - , closestHitShader( closestHitShader_ ) - , anyHitShader( anyHitShader_ ) - , intersectionShader( intersectionShader_ ) - {} - - RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; - const void* pNext = nullptr; - vk::RayTracingShaderGroupTypeNV type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; - }; - static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct RayTracingShaderGroupCreateInfoNV : public layout::RayTracingShaderGroupCreateInfoNV + struct RayTracingShaderGroupCreateInfoNV { VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral, uint32_t generalShader_ = 0, uint32_t closestHitShader_ = 0, uint32_t anyHitShader_ = 0, uint32_t intersectionShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::RayTracingShaderGroupCreateInfoNV( type_, generalShader_, closestHitShader_, anyHitShader_, intersectionShader_ ) + : type( type_ ) + , generalShader( generalShader_ ) + , closestHitShader( closestHitShader_ ) + , anyHitShader( anyHitShader_ ) + , intersectionShader( intersectionShader_ ) {} + vk::RayTracingShaderGroupCreateInfoNV & operator=( vk::RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RayTracingShaderGroupCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RayTracingShaderGroupCreateInfoNV( rhs ) - {} + { + *this = rhs; + } RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RayTracingShaderGroupCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58384,65 +52531,19 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RayTracingShaderGroupCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; + const void* pNext = nullptr; + vk::RayTracingShaderGroupTypeNV type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; }; static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RayTracingPipelineCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), - uint32_t stageCount_ = 0, - const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr, - uint32_t groupCount_ = 0, - const vk::RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr, - uint32_t maxRecursionDepth_ = 0, - vk::PipelineLayout layout_ = vk::PipelineLayout(), - vk::Pipeline basePipelineHandle_ = vk::Pipeline(), - int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , stageCount( stageCount_ ) - , pStages( pStages_ ) - , groupCount( groupCount_ ) - , pGroups( pGroups_ ) - , maxRecursionDepth( maxRecursionDepth_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - {} - - RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineCreateFlags flags; - uint32_t stageCount; - const vk::PipelineShaderStageCreateInfo* pStages; - uint32_t groupCount; - const vk::RayTracingShaderGroupCreateInfoNV* pGroups; - uint32_t maxRecursionDepth; - vk::PipelineLayout layout; - vk::Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct RayTracingPipelineCreateInfoNV : public layout::RayTracingPipelineCreateInfoNV + struct RayTracingPipelineCreateInfoNV { VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), uint32_t stageCount_ = 0, @@ -58453,16 +52554,31 @@ namespace VULKAN_HPP_NAMESPACE vk::PipelineLayout layout_ = vk::PipelineLayout(), vk::Pipeline basePipelineHandle_ = vk::Pipeline(), int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::RayTracingPipelineCreateInfoNV( flags_, stageCount_, pStages_, groupCount_, pGroups_, maxRecursionDepth_, layout_, basePipelineHandle_, basePipelineIndex_ ) + : flags( flags_ ) + , stageCount( stageCount_ ) + , pStages( pStages_ ) + , groupCount( groupCount_ ) + , pGroups( pGroups_ ) + , maxRecursionDepth( maxRecursionDepth_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) {} + vk::RayTracingPipelineCreateInfoNV & operator=( vk::RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RayTracingPipelineCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RayTracingPipelineCreateInfoNV( rhs ) - {} + { + *this = rhs; + } RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RayTracingPipelineCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58556,25 +52672,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RayTracingPipelineCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineCreateFlags flags; + uint32_t stageCount; + const vk::PipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const vk::RayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + vk::PipelineLayout layout; + vk::Pipeline basePipelineHandle; + int32_t basePipelineIndex; }; static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct RefreshCycleDurationGOOGLE { - RefreshCycleDurationGOOGLE() VULKAN_HPP_NOEXCEPT + RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = 0 ) VULKAN_HPP_NOEXCEPT + : refreshDuration( refreshDuration_ ) {} RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -58604,51 +52731,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassAttachmentBeginInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0, - const vk::ImageView* pAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT - : attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - {} - - RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR; - const void* pNext = nullptr; - uint32_t attachmentCount; - const vk::ImageView* pAttachments; - }; - static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassAttachmentBeginInfoKHR : public layout::RenderPassAttachmentBeginInfoKHR + struct RenderPassAttachmentBeginInfoKHR { VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0, const vk::ImageView* pAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassAttachmentBeginInfoKHR( attachmentCount_, pAttachments_ ) + : attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) {} + vk::RenderPassAttachmentBeginInfoKHR & operator=( vk::RenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassAttachmentBeginInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassAttachmentBeginInfoKHR( rhs ) - {} + { + *this = rhs; + } RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassAttachmentBeginInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58693,69 +52797,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassAttachmentBeginInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR; + const void* pNext = nullptr; + uint32_t attachmentCount; + const vk::ImageView* pAttachments; }; static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassBeginInfo - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassBeginInfo( vk::RenderPass renderPass_ = vk::RenderPass(), - vk::Framebuffer framebuffer_ = vk::Framebuffer(), - vk::Rect2D renderArea_ = vk::Rect2D(), - uint32_t clearValueCount_ = 0, - const vk::ClearValue* pClearValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : renderPass( renderPass_ ) - , framebuffer( framebuffer_ ) - , renderArea( renderArea_ ) - , clearValueCount( clearValueCount_ ) - , pClearValues( pClearValues_ ) - {} - - RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassBeginInfo; - const void* pNext = nullptr; - vk::RenderPass renderPass; - vk::Framebuffer framebuffer; - vk::Rect2D renderArea; - uint32_t clearValueCount; - const vk::ClearValue* pClearValues; - }; - static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassBeginInfo : public layout::RenderPassBeginInfo + struct RenderPassBeginInfo { VULKAN_HPP_CONSTEXPR RenderPassBeginInfo( vk::RenderPass renderPass_ = vk::RenderPass(), vk::Framebuffer framebuffer_ = vk::Framebuffer(), vk::Rect2D renderArea_ = vk::Rect2D(), uint32_t clearValueCount_ = 0, const vk::ClearValue* pClearValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassBeginInfo( renderPass_, framebuffer_, renderArea_, clearValueCount_, pClearValues_ ) + : renderPass( renderPass_ ) + , framebuffer( framebuffer_ ) + , renderArea( renderArea_ ) + , clearValueCount( clearValueCount_ ) + , pClearValues( pClearValues_ ) {} + vk::RenderPassBeginInfo & operator=( vk::RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassBeginInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassBeginInfo( rhs ) - {} + { + *this = rhs; + } RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassBeginInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58821,8 +52899,14 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassBeginInfo::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassBeginInfo; + const void* pNext = nullptr; + vk::RenderPass renderPass; + vk::Framebuffer framebuffer; + vk::Rect2D renderArea; + uint32_t clearValueCount; + const vk::ClearValue* pClearValues; }; static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -58853,12 +52937,12 @@ namespace VULKAN_HPP_NAMESPACE SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SubpassDescription& operator=( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -58986,12 +53070,12 @@ namespace VULKAN_HPP_NAMESPACE SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SubpassDependency& operator=( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -59075,53 +53159,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(), - uint32_t attachmentCount_ = 0, - const vk::AttachmentDescription* pAttachments_ = nullptr, - uint32_t subpassCount_ = 0, - const vk::SubpassDescription* pSubpasses_ = nullptr, - uint32_t dependencyCount_ = 0, - const vk::SubpassDependency* pDependencies_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , subpassCount( subpassCount_ ) - , pSubpasses( pSubpasses_ ) - , dependencyCount( dependencyCount_ ) - , pDependencies( pDependencies_ ) - {} - - RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassCreateInfo; - const void* pNext = nullptr; - vk::RenderPassCreateFlags flags; - uint32_t attachmentCount; - const vk::AttachmentDescription* pAttachments; - uint32_t subpassCount; - const vk::SubpassDescription* pSubpasses; - uint32_t dependencyCount; - const vk::SubpassDependency* pDependencies; - }; - static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassCreateInfo : public layout::RenderPassCreateInfo + struct RenderPassCreateInfo { VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, @@ -59130,16 +53168,29 @@ namespace VULKAN_HPP_NAMESPACE const vk::SubpassDescription* pSubpasses_ = nullptr, uint32_t dependencyCount_ = 0, const vk::SubpassDependency* pDependencies_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassCreateInfo( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_ ) + : flags( flags_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , subpassCount( subpassCount_ ) + , pSubpasses( pSubpasses_ ) + , dependencyCount( dependencyCount_ ) + , pDependencies( pDependencies_ ) {} + vk::RenderPassCreateInfo & operator=( vk::RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassCreateInfo( rhs ) - {} + { + *this = rhs; + } RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59219,71 +53270,21 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassCreateInfo; + const void* pNext = nullptr; + vk::RenderPassCreateFlags flags; + uint32_t attachmentCount; + const vk::AttachmentDescription* pAttachments; + uint32_t subpassCount; + const vk::SubpassDescription* pSubpasses; + uint32_t dependencyCount; + const vk::SubpassDependency* pDependencies; }; static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassDescription2KHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(), - vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, - uint32_t viewMask_ = 0, - uint32_t inputAttachmentCount_ = 0, - const vk::AttachmentReference2KHR* pInputAttachments_ = nullptr, - uint32_t colorAttachmentCount_ = 0, - const vk::AttachmentReference2KHR* pColorAttachments_ = nullptr, - const vk::AttachmentReference2KHR* pResolveAttachments_ = nullptr, - const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr, - uint32_t preserveAttachmentCount_ = 0, - const uint32_t* pPreserveAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , viewMask( viewMask_ ) - , inputAttachmentCount( inputAttachmentCount_ ) - , pInputAttachments( pInputAttachments_ ) - , colorAttachmentCount( colorAttachmentCount_ ) - , pColorAttachments( pColorAttachments_ ) - , pResolveAttachments( pResolveAttachments_ ) - , pDepthStencilAttachment( pDepthStencilAttachment_ ) - , preserveAttachmentCount( preserveAttachmentCount_ ) - , pPreserveAttachments( pPreserveAttachments_ ) - {} - - SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassDescription2KHR; - const void* pNext = nullptr; - vk::SubpassDescriptionFlags flags; - vk::PipelineBindPoint pipelineBindPoint; - uint32_t viewMask; - uint32_t inputAttachmentCount; - const vk::AttachmentReference2KHR* pInputAttachments; - uint32_t colorAttachmentCount; - const vk::AttachmentReference2KHR* pColorAttachments; - const vk::AttachmentReference2KHR* pResolveAttachments; - const vk::AttachmentReference2KHR* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; - }; - static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassDescription2KHR : public layout::SubpassDescription2KHR + struct SubpassDescription2KHR { VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(), vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, @@ -59296,16 +53297,33 @@ namespace VULKAN_HPP_NAMESPACE const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr, uint32_t preserveAttachmentCount_ = 0, const uint32_t* pPreserveAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDescription2KHR( flags_, pipelineBindPoint_, viewMask_, inputAttachmentCount_, pInputAttachments_, colorAttachmentCount_, pColorAttachments_, pResolveAttachments_, pDepthStencilAttachment_, preserveAttachmentCount_, pPreserveAttachments_ ) + : flags( flags_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , viewMask( viewMask_ ) + , inputAttachmentCount( inputAttachmentCount_ ) + , pInputAttachments( pInputAttachments_ ) + , colorAttachmentCount( colorAttachmentCount_ ) + , pColorAttachments( pColorAttachments_ ) + , pResolveAttachments( pResolveAttachments_ ) + , pDepthStencilAttachment( pDepthStencilAttachment_ ) + , preserveAttachmentCount( preserveAttachmentCount_ ) + , pPreserveAttachments( pPreserveAttachments_ ) {} + vk::SubpassDescription2KHR & operator=( vk::SubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDescription2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDescription2KHR( rhs ) - {} + { + *this = rhs; + } SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassDescription2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59413,62 +53431,25 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassDescription2KHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassDescription2KHR; + const void* pNext = nullptr; + vk::SubpassDescriptionFlags flags; + vk::PipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const vk::AttachmentReference2KHR* pInputAttachments; + uint32_t colorAttachmentCount; + const vk::AttachmentReference2KHR* pColorAttachments; + const vk::AttachmentReference2KHR* pResolveAttachments; + const vk::AttachmentReference2KHR* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; }; static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassDependency2KHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( uint32_t srcSubpass_ = 0, - uint32_t dstSubpass_ = 0, - vk::PipelineStageFlags srcStageMask_ = vk::PipelineStageFlags(), - vk::PipelineStageFlags dstStageMask_ = vk::PipelineStageFlags(), - vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), - vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), - vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(), - int32_t viewOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : srcSubpass( srcSubpass_ ) - , dstSubpass( dstSubpass_ ) - , srcStageMask( srcStageMask_ ) - , dstStageMask( dstStageMask_ ) - , srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , dependencyFlags( dependencyFlags_ ) - , viewOffset( viewOffset_ ) - {} - - SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassDependency2KHR; - const void* pNext = nullptr; - uint32_t srcSubpass; - uint32_t dstSubpass; - vk::PipelineStageFlags srcStageMask; - vk::PipelineStageFlags dstStageMask; - vk::AccessFlags srcAccessMask; - vk::AccessFlags dstAccessMask; - vk::DependencyFlags dependencyFlags; - int32_t viewOffset; - }; - static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassDependency2KHR : public layout::SubpassDependency2KHR + struct SubpassDependency2KHR { VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, @@ -59478,16 +53459,30 @@ namespace VULKAN_HPP_NAMESPACE vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(), int32_t viewOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDependency2KHR( srcSubpass_, dstSubpass_, srcStageMask_, dstStageMask_, srcAccessMask_, dstAccessMask_, dependencyFlags_, viewOffset_ ) + : srcSubpass( srcSubpass_ ) + , dstSubpass( dstSubpass_ ) + , srcStageMask( srcStageMask_ ) + , dstStageMask( dstStageMask_ ) + , srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , dependencyFlags( dependencyFlags_ ) + , viewOffset( viewOffset_ ) {} + vk::SubpassDependency2KHR & operator=( vk::SubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDependency2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDependency2KHR( rhs ) - {} + { + *this = rhs; + } SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassDependency2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59574,65 +53569,22 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassDependency2KHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassDependency2KHR; + const void* pNext = nullptr; + uint32_t srcSubpass; + uint32_t dstSubpass; + vk::PipelineStageFlags srcStageMask; + vk::PipelineStageFlags dstStageMask; + vk::AccessFlags srcAccessMask; + vk::AccessFlags dstAccessMask; + vk::DependencyFlags dependencyFlags; + int32_t viewOffset; }; static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassCreateInfo2KHR - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(), - uint32_t attachmentCount_ = 0, - const vk::AttachmentDescription2KHR* pAttachments_ = nullptr, - uint32_t subpassCount_ = 0, - const vk::SubpassDescription2KHR* pSubpasses_ = nullptr, - uint32_t dependencyCount_ = 0, - const vk::SubpassDependency2KHR* pDependencies_ = nullptr, - uint32_t correlatedViewMaskCount_ = 0, - const uint32_t* pCorrelatedViewMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , subpassCount( subpassCount_ ) - , pSubpasses( pSubpasses_ ) - , dependencyCount( dependencyCount_ ) - , pDependencies( pDependencies_ ) - , correlatedViewMaskCount( correlatedViewMaskCount_ ) - , pCorrelatedViewMasks( pCorrelatedViewMasks_ ) - {} - - RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassCreateInfo2KHR; - const void* pNext = nullptr; - vk::RenderPassCreateFlags flags; - uint32_t attachmentCount; - const vk::AttachmentDescription2KHR* pAttachments; - uint32_t subpassCount; - const vk::SubpassDescription2KHR* pSubpasses; - uint32_t dependencyCount; - const vk::SubpassDependency2KHR* pDependencies; - uint32_t correlatedViewMaskCount; - const uint32_t* pCorrelatedViewMasks; - }; - static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassCreateInfo2KHR : public layout::RenderPassCreateInfo2KHR + struct RenderPassCreateInfo2KHR { VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, @@ -59643,16 +53595,31 @@ namespace VULKAN_HPP_NAMESPACE const vk::SubpassDependency2KHR* pDependencies_ = nullptr, uint32_t correlatedViewMaskCount_ = 0, const uint32_t* pCorrelatedViewMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassCreateInfo2KHR( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_, correlatedViewMaskCount_, pCorrelatedViewMasks_ ) + : flags( flags_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , subpassCount( subpassCount_ ) + , pSubpasses( pSubpasses_ ) + , dependencyCount( dependencyCount_ ) + , pDependencies( pDependencies_ ) + , correlatedViewMaskCount( correlatedViewMaskCount_ ) + , pCorrelatedViewMasks( pCorrelatedViewMasks_ ) {} + vk::RenderPassCreateInfo2KHR & operator=( vk::RenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassCreateInfo2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassCreateInfo2KHR( rhs ) - {} + { + *this = rhs; + } RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassCreateInfo2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59746,53 +53713,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassCreateInfo2KHR::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassCreateInfo2KHR; + const void* pNext = nullptr; + vk::RenderPassCreateFlags flags; + uint32_t attachmentCount; + const vk::AttachmentDescription2KHR* pAttachments; + uint32_t subpassCount; + const vk::SubpassDescription2KHR* pSubpasses; + uint32_t dependencyCount; + const vk::SubpassDependency2KHR* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; }; static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassFragmentDensityMapCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() ) VULKAN_HPP_NOEXCEPT - : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ ) - {} - - RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; - const void* pNext = nullptr; - vk::AttachmentReference fragmentDensityMapAttachment; - }; - static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassFragmentDensityMapCreateInfoEXT : public layout::RenderPassFragmentDensityMapCreateInfoEXT + struct RenderPassFragmentDensityMapCreateInfoEXT { VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassFragmentDensityMapCreateInfoEXT( fragmentDensityMapAttachment_ ) + : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ ) {} + vk::RenderPassFragmentDensityMapCreateInfoEXT & operator=( vk::RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassFragmentDensityMapCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassFragmentDensityMapCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassFragmentDensityMapCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59830,57 +53786,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassFragmentDensityMapCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; + const void* pNext = nullptr; + vk::AttachmentReference fragmentDensityMapAttachment; }; static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassInputAttachmentAspectCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0, - const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr ) VULKAN_HPP_NOEXCEPT - : aspectReferenceCount( aspectReferenceCount_ ) - , pAspectReferences( pAspectReferences_ ) - {} - - RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; - const void* pNext = nullptr; - uint32_t aspectReferenceCount; - const vk::InputAttachmentAspectReference* pAspectReferences; - }; - static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassInputAttachmentAspectCreateInfo : public layout::RenderPassInputAttachmentAspectCreateInfo + struct RenderPassInputAttachmentAspectCreateInfo { VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0, const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassInputAttachmentAspectCreateInfo( aspectReferenceCount_, pAspectReferences_ ) + : aspectReferenceCount( aspectReferenceCount_ ) + , pAspectReferences( pAspectReferences_ ) {} + vk::RenderPassInputAttachmentAspectCreateInfo & operator=( vk::RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassInputAttachmentAspectCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassInputAttachmentAspectCreateInfo( rhs ) - {} + { + *this = rhs; + } RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassInputAttachmentAspectCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59925,56 +53860,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassInputAttachmentAspectCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; + const void* pNext = nullptr; + uint32_t aspectReferenceCount; + const vk::InputAttachmentAspectReference* pAspectReferences; }; static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassMultiviewCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0, - const uint32_t* pViewMasks_ = nullptr, - uint32_t dependencyCount_ = 0, - const int32_t* pViewOffsets_ = nullptr, - uint32_t correlationMaskCount_ = 0, - const uint32_t* pCorrelationMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : subpassCount( subpassCount_ ) - , pViewMasks( pViewMasks_ ) - , dependencyCount( dependencyCount_ ) - , pViewOffsets( pViewOffsets_ ) - , correlationMaskCount( correlationMaskCount_ ) - , pCorrelationMasks( pCorrelationMasks_ ) - {} - - RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; - const void* pNext = nullptr; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; - }; - static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassMultiviewCreateInfo : public layout::RenderPassMultiviewCreateInfo + struct RenderPassMultiviewCreateInfo { VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0, const uint32_t* pViewMasks_ = nullptr, @@ -59982,16 +53877,28 @@ namespace VULKAN_HPP_NAMESPACE const int32_t* pViewOffsets_ = nullptr, uint32_t correlationMaskCount_ = 0, const uint32_t* pCorrelationMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassMultiviewCreateInfo( subpassCount_, pViewMasks_, dependencyCount_, pViewOffsets_, correlationMaskCount_, pCorrelationMasks_ ) + : subpassCount( subpassCount_ ) + , pViewMasks( pViewMasks_ ) + , dependencyCount( dependencyCount_ ) + , pViewOffsets( pViewOffsets_ ) + , correlationMaskCount( correlationMaskCount_ ) + , pCorrelationMasks( pCorrelationMasks_ ) {} + vk::RenderPassMultiviewCreateInfo & operator=( vk::RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassMultiviewCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassMultiviewCreateInfo( rhs ) - {} + { + *this = rhs; + } RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassMultiviewCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60064,8 +53971,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassMultiviewCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; + const void* pNext = nullptr; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; }; static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -60080,12 +53994,12 @@ namespace VULKAN_HPP_NAMESPACE SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -60129,59 +54043,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassSampleLocationsBeginInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, - const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, - uint32_t postSubpassSampleLocationsCount_ = 0, - const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT - : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) - , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ) - , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ) - , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ ) - {} - - RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; - const void* pNext = nullptr; - uint32_t attachmentInitialSampleLocationsCount; - const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations; - }; - static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassSampleLocationsBeginInfoEXT : public layout::RenderPassSampleLocationsBeginInfoEXT + struct RenderPassSampleLocationsBeginInfoEXT { VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, uint32_t postSubpassSampleLocationsCount_ = 0, const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassSampleLocationsBeginInfoEXT( attachmentInitialSampleLocationsCount_, pAttachmentInitialSampleLocations_, postSubpassSampleLocationsCount_, pPostSubpassSampleLocations_ ) + : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) + , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ) + , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ) + , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ ) {} + vk::RenderPassSampleLocationsBeginInfoEXT & operator=( vk::RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassSampleLocationsBeginInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassSampleLocationsBeginInfoEXT( rhs ) - {} + { + *this = rhs; + } RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassSampleLocationsBeginInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60240,86 +54127,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassSampleLocationsBeginInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; + const void* pNext = nullptr; + uint32_t attachmentInitialSampleLocationsCount; + const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations; }; static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SamplerCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(), - vk::Filter magFilter_ = vk::Filter::eNearest, - vk::Filter minFilter_ = vk::Filter::eNearest, - vk::SamplerMipmapMode mipmapMode_ = vk::SamplerMipmapMode::eNearest, - vk::SamplerAddressMode addressModeU_ = vk::SamplerAddressMode::eRepeat, - vk::SamplerAddressMode addressModeV_ = vk::SamplerAddressMode::eRepeat, - vk::SamplerAddressMode addressModeW_ = vk::SamplerAddressMode::eRepeat, - float mipLodBias_ = 0, - vk::Bool32 anisotropyEnable_ = 0, - float maxAnisotropy_ = 0, - vk::Bool32 compareEnable_ = 0, - vk::CompareOp compareOp_ = vk::CompareOp::eNever, - float minLod_ = 0, - float maxLod_ = 0, - vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack, - vk::Bool32 unnormalizedCoordinates_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , magFilter( magFilter_ ) - , minFilter( minFilter_ ) - , mipmapMode( mipmapMode_ ) - , addressModeU( addressModeU_ ) - , addressModeV( addressModeV_ ) - , addressModeW( addressModeW_ ) - , mipLodBias( mipLodBias_ ) - , anisotropyEnable( anisotropyEnable_ ) - , maxAnisotropy( maxAnisotropy_ ) - , compareEnable( compareEnable_ ) - , compareOp( compareOp_ ) - , minLod( minLod_ ) - , maxLod( maxLod_ ) - , borderColor( borderColor_ ) - , unnormalizedCoordinates( unnormalizedCoordinates_ ) - {} - - SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerCreateInfo; - const void* pNext = nullptr; - vk::SamplerCreateFlags flags; - vk::Filter magFilter; - vk::Filter minFilter; - vk::SamplerMipmapMode mipmapMode; - vk::SamplerAddressMode addressModeU; - vk::SamplerAddressMode addressModeV; - vk::SamplerAddressMode addressModeW; - float mipLodBias; - vk::Bool32 anisotropyEnable; - float maxAnisotropy; - vk::Bool32 compareEnable; - vk::CompareOp compareOp; - float minLod; - float maxLod; - vk::BorderColor borderColor; - vk::Bool32 unnormalizedCoordinates; - }; - static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct SamplerCreateInfo : public layout::SamplerCreateInfo + struct SamplerCreateInfo { VULKAN_HPP_CONSTEXPR SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(), vk::Filter magFilter_ = vk::Filter::eNearest, @@ -60337,16 +54156,38 @@ namespace VULKAN_HPP_NAMESPACE float maxLod_ = 0, vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack, vk::Bool32 unnormalizedCoordinates_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SamplerCreateInfo( flags_, magFilter_, minFilter_, mipmapMode_, addressModeU_, addressModeV_, addressModeW_, mipLodBias_, anisotropyEnable_, maxAnisotropy_, compareEnable_, compareOp_, minLod_, maxLod_, borderColor_, unnormalizedCoordinates_ ) + : flags( flags_ ) + , magFilter( magFilter_ ) + , minFilter( minFilter_ ) + , mipmapMode( mipmapMode_ ) + , addressModeU( addressModeU_ ) + , addressModeV( addressModeV_ ) + , addressModeW( addressModeW_ ) + , mipLodBias( mipLodBias_ ) + , anisotropyEnable( anisotropyEnable_ ) + , maxAnisotropy( maxAnisotropy_ ) + , compareEnable( compareEnable_ ) + , compareOp( compareOp_ ) + , minLod( minLod_ ) + , maxLod( maxLod_ ) + , borderColor( borderColor_ ) + , unnormalizedCoordinates( unnormalizedCoordinates_ ) {} + vk::SamplerCreateInfo & operator=( vk::SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerCreateInfo( rhs ) - {} + { + *this = rhs; + } SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60489,53 +54330,49 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eSamplerCreateInfo; + const void* pNext = nullptr; + vk::SamplerCreateFlags flags; + vk::Filter magFilter; + vk::Filter minFilter; + vk::SamplerMipmapMode mipmapMode; + vk::SamplerAddressMode addressModeU; + vk::SamplerAddressMode addressModeV; + vk::SamplerAddressMode addressModeW; + float mipLodBias; + vk::Bool32 anisotropyEnable; + float maxAnisotropy; + vk::Bool32 compareEnable; + vk::CompareOp compareOp; + float minLod; + float maxLod; + vk::BorderColor borderColor; + vk::Bool32 unnormalizedCoordinates; }; static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SamplerReductionModeCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage ) VULKAN_HPP_NOEXCEPT - : reductionMode( reductionMode_ ) - {} - - SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT; - const void* pNext = nullptr; - vk::SamplerReductionModeEXT reductionMode; - }; - static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SamplerReductionModeCreateInfoEXT : public layout::SamplerReductionModeCreateInfoEXT + struct SamplerReductionModeCreateInfoEXT { VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage ) VULKAN_HPP_NOEXCEPT - : layout::SamplerReductionModeCreateInfoEXT( reductionMode_ ) + : reductionMode( reductionMode_ ) {} + vk::SamplerReductionModeCreateInfoEXT & operator=( vk::SamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerReductionModeCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerReductionModeCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerReductionModeCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60573,62 +54410,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerReductionModeCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT; + const void* pNext = nullptr; + vk::SamplerReductionModeEXT reductionMode; }; static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SamplerYcbcrConversionCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined, - vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity, - vk::SamplerYcbcrRange ycbcrRange_ = vk::SamplerYcbcrRange::eItuFull, - vk::ComponentMapping components_ = vk::ComponentMapping(), - vk::ChromaLocation xChromaOffset_ = vk::ChromaLocation::eCositedEven, - vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven, - vk::Filter chromaFilter_ = vk::Filter::eNearest, - vk::Bool32 forceExplicitReconstruction_ = 0 ) VULKAN_HPP_NOEXCEPT - : format( format_ ) - , ycbcrModel( ycbcrModel_ ) - , ycbcrRange( ycbcrRange_ ) - , components( components_ ) - , xChromaOffset( xChromaOffset_ ) - , yChromaOffset( yChromaOffset_ ) - , chromaFilter( chromaFilter_ ) - , forceExplicitReconstruction( forceExplicitReconstruction_ ) - {} - - SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; - const void* pNext = nullptr; - vk::Format format; - vk::SamplerYcbcrModelConversion ycbcrModel; - vk::SamplerYcbcrRange ycbcrRange; - vk::ComponentMapping components; - vk::ChromaLocation xChromaOffset; - vk::ChromaLocation yChromaOffset; - vk::Filter chromaFilter; - vk::Bool32 forceExplicitReconstruction; - }; - static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct SamplerYcbcrConversionCreateInfo : public layout::SamplerYcbcrConversionCreateInfo + struct SamplerYcbcrConversionCreateInfo { VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined, vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity, @@ -60638,16 +54428,30 @@ namespace VULKAN_HPP_NAMESPACE vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven, vk::Filter chromaFilter_ = vk::Filter::eNearest, vk::Bool32 forceExplicitReconstruction_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionCreateInfo( format_, ycbcrModel_, ycbcrRange_, components_, xChromaOffset_, yChromaOffset_, chromaFilter_, forceExplicitReconstruction_ ) + : format( format_ ) + , ycbcrModel( ycbcrModel_ ) + , ycbcrRange( ycbcrRange_ ) + , components( components_ ) + , xChromaOffset( xChromaOffset_ ) + , yChromaOffset( yChromaOffset_ ) + , chromaFilter( chromaFilter_ ) + , forceExplicitReconstruction( forceExplicitReconstruction_ ) {} + vk::SamplerYcbcrConversionCreateInfo & operator=( vk::SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionCreateInfo( rhs ) - {} + { + *this = rhs; + } SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerYcbcrConversionCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60734,52 +54538,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerYcbcrConversionCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; + const void* pNext = nullptr; + vk::Format format; + vk::SamplerYcbcrModelConversion ycbcrModel; + vk::SamplerYcbcrRange ycbcrRange; + vk::ComponentMapping components; + vk::ChromaLocation xChromaOffset; + vk::ChromaLocation yChromaOffset; + vk::Filter chromaFilter; + vk::Bool32 forceExplicitReconstruction; }; static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SamplerYcbcrConversionImageFormatProperties { - struct SamplerYcbcrConversionImageFormatProperties - { - protected: - SamplerYcbcrConversionImageFormatProperties() VULKAN_HPP_NOEXCEPT - {} - - SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; - void* pNext = nullptr; - uint32_t combinedImageSamplerDescriptorCount; - }; - static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "layout struct and wrapper have different size!" ); - } - - struct SamplerYcbcrConversionImageFormatProperties : public layout::SamplerYcbcrConversionImageFormatProperties - { - SamplerYcbcrConversionImageFormatProperties() VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionImageFormatProperties() + SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT + : combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ ) {} + vk::SamplerYcbcrConversionImageFormatProperties & operator=( vk::SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionImageFormatProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionImageFormatProperties( rhs ) - {} + { + *this = rhs; + } SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerYcbcrConversionImageFormatProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60805,53 +54598,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerYcbcrConversionImageFormatProperties::sType; + public: + const vk::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; + void* pNext = nullptr; + uint32_t combinedImageSamplerDescriptorCount; }; static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SamplerYcbcrConversionInfo - { - protected: - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() ) VULKAN_HPP_NOEXCEPT - : conversion( conversion_ ) - {} - - SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerYcbcrConversionInfo; - const void* pNext = nullptr; - vk::SamplerYcbcrConversion conversion; - }; - static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "layout struct and wrapper have different size!" ); - } - - struct SamplerYcbcrConversionInfo : public layout::SamplerYcbcrConversionInfo + struct SamplerYcbcrConversionInfo { VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionInfo( conversion_ ) + : conversion( conversion_ ) {} + vk::SamplerYcbcrConversionInfo & operator=( vk::SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionInfo( rhs ) - {} + { + *this = rhs; + } SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerYcbcrConversionInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60889,53 +54663,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerYcbcrConversionInfo::sType; + public: + const vk::StructureType sType = StructureType::eSamplerYcbcrConversionInfo; + const void* pNext = nullptr; + vk::SamplerYcbcrConversion conversion; }; static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SemaphoreCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - {} - - SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreCreateInfo; - const void* pNext = nullptr; - vk::SemaphoreCreateFlags flags; - }; - static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreCreateInfo : public layout::SemaphoreCreateInfo + struct SemaphoreCreateInfo { VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreCreateInfo( flags_ ) + : flags( flags_ ) {} + vk::SemaphoreCreateInfo & operator=( vk::SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreCreateInfo( rhs ) - {} + { + *this = rhs; + } SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60973,57 +54728,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreCreateInfo; + const void* pNext = nullptr; + vk::SemaphoreCreateFlags flags; }; static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SemaphoreGetFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , handleType( handleType_ ) - {} - - SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreGetFdInfoKHR : public layout::SemaphoreGetFdInfoKHR + struct SemaphoreGetFdInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreGetFdInfoKHR( semaphore_, handleType_ ) + : semaphore( semaphore_ ) + , handleType( handleType_ ) {} + vk::SemaphoreGetFdInfoKHR & operator=( vk::SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreGetFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreGetFdInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreGetFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61068,59 +54802,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreGetFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; }; static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct SemaphoreGetWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , handleType( handleType_ ) - {} - - SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreGetWin32HandleInfoKHR : public layout::SemaphoreGetWin32HandleInfoKHR + struct SemaphoreGetWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreGetWin32HandleInfoKHR( semaphore_, handleType_ ) + : semaphore( semaphore_ ) + , handleType( handleType_ ) {} + vk::SemaphoreGetWin32HandleInfoKHR & operator=( vk::SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreGetWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreGetWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61165,58 +54879,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreGetWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; }; static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct SemaphoreSignalInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreSignalInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - uint64_t value_ = 0 ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , value( value_ ) - {} - - SemaphoreSignalInfoKHR( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreSignalInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - uint64_t value; - }; - static_assert( sizeof( SemaphoreSignalInfoKHR ) == sizeof( VkSemaphoreSignalInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreSignalInfoKHR : public layout::SemaphoreSignalInfoKHR + struct SemaphoreSignalInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreSignalInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), uint64_t value_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreSignalInfoKHR( semaphore_, value_ ) + : semaphore( semaphore_ ) + , value( value_ ) {} + vk::SemaphoreSignalInfoKHR & operator=( vk::SemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreSignalInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreSignalInfoKHR( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreSignalInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreSignalInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61261,57 +54955,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreSignalInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreSignalInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + uint64_t value; }; static_assert( sizeof( SemaphoreSignalInfoKHR ) == sizeof( VkSemaphoreSignalInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SemaphoreTypeCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfoKHR( vk::SemaphoreTypeKHR semaphoreType_ = vk::SemaphoreTypeKHR::eBinary, - uint64_t initialValue_ = 0 ) VULKAN_HPP_NOEXCEPT - : semaphoreType( semaphoreType_ ) - , initialValue( initialValue_ ) - {} - - SemaphoreTypeCreateInfoKHR( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreTypeCreateInfoKHR; - const void* pNext = nullptr; - vk::SemaphoreTypeKHR semaphoreType; - uint64_t initialValue; - }; - static_assert( sizeof( SemaphoreTypeCreateInfoKHR ) == sizeof( VkSemaphoreTypeCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreTypeCreateInfoKHR : public layout::SemaphoreTypeCreateInfoKHR + struct SemaphoreTypeCreateInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfoKHR( vk::SemaphoreTypeKHR semaphoreType_ = vk::SemaphoreTypeKHR::eBinary, uint64_t initialValue_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreTypeCreateInfoKHR( semaphoreType_, initialValue_ ) + : semaphoreType( semaphoreType_ ) + , initialValue( initialValue_ ) {} + vk::SemaphoreTypeCreateInfoKHR & operator=( vk::SemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreTypeCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreTypeCreateInfoKHR( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreTypeCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreTypeCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61356,65 +55030,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreTypeCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreTypeCreateInfoKHR; + const void* pNext = nullptr; + vk::SemaphoreTypeKHR semaphoreType; + uint64_t initialValue; }; static_assert( sizeof( SemaphoreTypeCreateInfoKHR ) == sizeof( VkSemaphoreTypeCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SemaphoreWaitInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreWaitInfoKHR( vk::SemaphoreWaitFlagsKHR flags_ = vk::SemaphoreWaitFlagsKHR(), - uint32_t semaphoreCount_ = 0, - const vk::Semaphore* pSemaphores_ = nullptr, - const uint64_t* pValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , semaphoreCount( semaphoreCount_ ) - , pSemaphores( pSemaphores_ ) - , pValues( pValues_ ) - {} - - SemaphoreWaitInfoKHR( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreWaitInfoKHR; - const void* pNext = nullptr; - vk::SemaphoreWaitFlagsKHR flags; - uint32_t semaphoreCount; - const vk::Semaphore* pSemaphores; - const uint64_t* pValues; - }; - static_assert( sizeof( SemaphoreWaitInfoKHR ) == sizeof( VkSemaphoreWaitInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreWaitInfoKHR : public layout::SemaphoreWaitInfoKHR + struct SemaphoreWaitInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreWaitInfoKHR( vk::SemaphoreWaitFlagsKHR flags_ = vk::SemaphoreWaitFlagsKHR(), uint32_t semaphoreCount_ = 0, const vk::Semaphore* pSemaphores_ = nullptr, const uint64_t* pValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreWaitInfoKHR( flags_, semaphoreCount_, pSemaphores_, pValues_ ) + : flags( flags_ ) + , semaphoreCount( semaphoreCount_ ) + , pSemaphores( pSemaphores_ ) + , pValues( pValues_ ) {} + vk::SemaphoreWaitInfoKHR & operator=( vk::SemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreWaitInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreWaitInfoKHR( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreWaitInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreWaitInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61473,61 +55123,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreWaitInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreWaitInfoKHR; + const void* pNext = nullptr; + vk::SemaphoreWaitFlagsKHR flags; + uint32_t semaphoreCount; + const vk::Semaphore* pSemaphores; + const uint64_t* pValues; }; static_assert( sizeof( SemaphoreWaitInfoKHR ) == sizeof( VkSemaphoreWaitInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ShaderModuleCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(), - size_t codeSize_ = 0, - const uint32_t* pCode_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , codeSize( codeSize_ ) - , pCode( pCode_ ) - {} - - ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eShaderModuleCreateInfo; - const void* pNext = nullptr; - vk::ShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; - }; - static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ShaderModuleCreateInfo : public layout::ShaderModuleCreateInfo + struct ShaderModuleCreateInfo { VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(), size_t codeSize_ = 0, const uint32_t* pCode_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ShaderModuleCreateInfo( flags_, codeSize_, pCode_ ) + : flags( flags_ ) + , codeSize( codeSize_ ) + , pCode( pCode_ ) {} + vk::ShaderModuleCreateInfo & operator=( vk::ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ShaderModuleCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ShaderModuleCreateInfo( rhs ) - {} + { + *this = rhs; + } ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ShaderModuleCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61579,53 +55209,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ShaderModuleCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eShaderModuleCreateInfo; + const void* pNext = nullptr; + vk::ShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; }; static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ShaderModuleValidationCacheCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() ) VULKAN_HPP_NOEXCEPT - : validationCache( validationCache_ ) - {} - - ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; - const void* pNext = nullptr; - vk::ValidationCacheEXT validationCache; - }; - static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ShaderModuleValidationCacheCreateInfoEXT : public layout::ShaderModuleValidationCacheCreateInfoEXT + struct ShaderModuleValidationCacheCreateInfoEXT { VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() ) VULKAN_HPP_NOEXCEPT - : layout::ShaderModuleValidationCacheCreateInfoEXT( validationCache_ ) + : validationCache( validationCache_ ) {} + vk::ShaderModuleValidationCacheCreateInfoEXT & operator=( vk::ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ShaderModuleValidationCacheCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ShaderModuleValidationCacheCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ShaderModuleValidationCacheCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61663,25 +55276,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ShaderModuleValidationCacheCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; + const void* pNext = nullptr; + vk::ValidationCacheEXT validationCache; }; static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct ShaderResourceUsageAMD { - ShaderResourceUsageAMD() VULKAN_HPP_NOEXCEPT + ShaderResourceUsageAMD( uint32_t numUsedVgprs_ = 0, + uint32_t numUsedSgprs_ = 0, + uint32_t ldsSizePerLocalWorkGroup_ = 0, + size_t ldsUsageSizeInBytes_ = 0, + size_t scratchMemUsageInBytes_ = 0 ) VULKAN_HPP_NOEXCEPT + : numUsedVgprs( numUsedVgprs_ ) + , numUsedSgprs( numUsedSgprs_ ) + , ldsSizePerLocalWorkGroup( ldsSizePerLocalWorkGroup_ ) + , ldsUsageSizeInBytes( ldsUsageSizeInBytes_ ) + , scratchMemUsageInBytes( scratchMemUsageInBytes_ ) {} ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ShaderResourceUsageAMD& operator=( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -61721,17 +55345,32 @@ namespace VULKAN_HPP_NAMESPACE struct ShaderStatisticsInfoAMD { - ShaderStatisticsInfoAMD() VULKAN_HPP_NOEXCEPT - {} + ShaderStatisticsInfoAMD( vk::ShaderStageFlags shaderStageMask_ = vk::ShaderStageFlags(), + vk::ShaderResourceUsageAMD resourceUsage_ = vk::ShaderResourceUsageAMD(), + uint32_t numPhysicalVgprs_ = 0, + uint32_t numPhysicalSgprs_ = 0, + uint32_t numAvailableVgprs_ = 0, + uint32_t numAvailableSgprs_ = 0, + std::array const& computeWorkGroupSize_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT + : shaderStageMask( shaderStageMask_ ) + , resourceUsage( resourceUsage_ ) + , numPhysicalVgprs( numPhysicalVgprs_ ) + , numPhysicalSgprs( numPhysicalSgprs_ ) + , numAvailableVgprs( numAvailableVgprs_ ) + , numAvailableSgprs( numAvailableSgprs_ ) + , computeWorkGroupSize{} + { + vk::ConstExpressionArrayCopy::copy( computeWorkGroupSize, computeWorkGroupSize_ ); + } ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ShaderStatisticsInfoAMD& operator=( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -61773,46 +55412,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SharedPresentSurfaceCapabilitiesKHR { - struct SharedPresentSurfaceCapabilitiesKHR - { - protected: - SharedPresentSurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT - {} - - SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; - void* pNext = nullptr; - vk::ImageUsageFlags sharedPresentSupportedUsageFlags; - }; - static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct SharedPresentSurfaceCapabilitiesKHR : public layout::SharedPresentSurfaceCapabilitiesKHR - { - SharedPresentSurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT - : layout::SharedPresentSurfaceCapabilitiesKHR() + SharedPresentSurfaceCapabilitiesKHR( vk::ImageUsageFlags sharedPresentSupportedUsageFlags_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT + : sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ ) {} + vk::SharedPresentSurfaceCapabilitiesKHR & operator=( vk::SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SharedPresentSurfaceCapabilitiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SharedPresentSurfaceCapabilitiesKHR( rhs ) - {} + { + *this = rhs; + } SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SharedPresentSurfaceCapabilitiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61838,25 +55457,32 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SharedPresentSurfaceCapabilitiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; + void* pNext = nullptr; + vk::ImageUsageFlags sharedPresentSupportedUsageFlags; }; static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct SparseImageFormatProperties { - SparseImageFormatProperties() VULKAN_HPP_NOEXCEPT + SparseImageFormatProperties( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(), + vk::Extent3D imageGranularity_ = vk::Extent3D(), + vk::SparseImageFormatFlags flags_ = vk::SparseImageFormatFlags() ) VULKAN_HPP_NOEXCEPT + : aspectMask( aspectMask_ ) + , imageGranularity( imageGranularity_ ) + , flags( flags_ ) {} SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageFormatProperties& operator=( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -61890,46 +55516,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SparseImageFormatProperties2 { - struct SparseImageFormatProperties2 - { - protected: - SparseImageFormatProperties2() VULKAN_HPP_NOEXCEPT - {} - - SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSparseImageFormatProperties2; - void* pNext = nullptr; - vk::SparseImageFormatProperties properties; - }; - static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct SparseImageFormatProperties2 : public layout::SparseImageFormatProperties2 - { - SparseImageFormatProperties2() VULKAN_HPP_NOEXCEPT - : layout::SparseImageFormatProperties2() + SparseImageFormatProperties2( vk::SparseImageFormatProperties properties_ = vk::SparseImageFormatProperties() ) VULKAN_HPP_NOEXCEPT + : properties( properties_ ) {} + vk::SparseImageFormatProperties2 & operator=( vk::SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SparseImageFormatProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SparseImageFormatProperties2( rhs ) - {} + { + *this = rhs; + } SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SparseImageFormatProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61955,25 +55561,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SparseImageFormatProperties2::sType; + public: + const vk::StructureType sType = StructureType::eSparseImageFormatProperties2; + void* pNext = nullptr; + vk::SparseImageFormatProperties properties; }; static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct SparseImageMemoryRequirements { - SparseImageMemoryRequirements() VULKAN_HPP_NOEXCEPT + SparseImageMemoryRequirements( vk::SparseImageFormatProperties formatProperties_ = vk::SparseImageFormatProperties(), + uint32_t imageMipTailFirstLod_ = 0, + vk::DeviceSize imageMipTailSize_ = 0, + vk::DeviceSize imageMipTailOffset_ = 0, + vk::DeviceSize imageMipTailStride_ = 0 ) VULKAN_HPP_NOEXCEPT + : formatProperties( formatProperties_ ) + , imageMipTailFirstLod( imageMipTailFirstLod_ ) + , imageMipTailSize( imageMipTailSize_ ) + , imageMipTailOffset( imageMipTailOffset_ ) + , imageMipTailStride( imageMipTailStride_ ) {} SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageMemoryRequirements& operator=( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -62011,46 +55628,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SparseImageMemoryRequirements2 { - struct SparseImageMemoryRequirements2 - { - protected: - SparseImageMemoryRequirements2() VULKAN_HPP_NOEXCEPT - {} - - SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSparseImageMemoryRequirements2; - void* pNext = nullptr; - vk::SparseImageMemoryRequirements memoryRequirements; - }; - static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "layout struct and wrapper have different size!" ); - } - - struct SparseImageMemoryRequirements2 : public layout::SparseImageMemoryRequirements2 - { - SparseImageMemoryRequirements2() VULKAN_HPP_NOEXCEPT - : layout::SparseImageMemoryRequirements2() + SparseImageMemoryRequirements2( vk::SparseImageMemoryRequirements memoryRequirements_ = vk::SparseImageMemoryRequirements() ) VULKAN_HPP_NOEXCEPT + : memoryRequirements( memoryRequirements_ ) {} + vk::SparseImageMemoryRequirements2 & operator=( vk::SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SparseImageMemoryRequirements2 ) - sizeof( vk::StructureType ) ); + return *this; + } + SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SparseImageMemoryRequirements2( rhs ) - {} + { + *this = rhs; + } SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SparseImageMemoryRequirements2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62076,59 +55673,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SparseImageMemoryRequirements2::sType; + public: + const vk::StructureType sType = StructureType::eSparseImageMemoryRequirements2; + void* pNext = nullptr; + vk::SparseImageMemoryRequirements memoryRequirements; }; static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_GGP - namespace layout - { - struct StreamDescriptorSurfaceCreateInfoGGP - { - protected: - VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(), - GgpStreamDescriptor streamDescriptor_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , streamDescriptor( streamDescriptor_ ) - {} - - StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; - const void* pNext = nullptr; - vk::StreamDescriptorSurfaceCreateFlagsGGP flags; - GgpStreamDescriptor streamDescriptor; - }; - static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "layout struct and wrapper have different size!" ); - } - - struct StreamDescriptorSurfaceCreateInfoGGP : public layout::StreamDescriptorSurfaceCreateInfoGGP + struct StreamDescriptorSurfaceCreateInfoGGP { VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(), GgpStreamDescriptor streamDescriptor_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::StreamDescriptorSurfaceCreateInfoGGP( flags_, streamDescriptor_ ) + : flags( flags_ ) + , streamDescriptor( streamDescriptor_ ) {} + vk::StreamDescriptorSurfaceCreateInfoGGP & operator=( vk::StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::StreamDescriptorSurfaceCreateInfoGGP ) - sizeof( vk::StructureType ) ); + return *this; + } + StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::StreamDescriptorSurfaceCreateInfoGGP( rhs ) - {} + { + *this = rhs; + } StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::StreamDescriptorSurfaceCreateInfoGGP::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62173,60 +55749,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::StreamDescriptorSurfaceCreateInfoGGP::sType; + public: + const vk::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; + const void* pNext = nullptr; + vk::StreamDescriptorSurfaceCreateFlagsGGP flags; + GgpStreamDescriptor streamDescriptor; }; static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_GGP*/ - namespace layout - { - struct SubmitInfo - { - protected: - VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = 0, - const vk::Semaphore* pWaitSemaphores_ = nullptr, - const vk::PipelineStageFlags* pWaitDstStageMask_ = nullptr, - uint32_t commandBufferCount_ = 0, - const vk::CommandBuffer* pCommandBuffers_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , pWaitDstStageMask( pWaitDstStageMask_ ) - , commandBufferCount( commandBufferCount_ ) - , pCommandBuffers( pCommandBuffers_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) - {} - - SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubmitInfo& operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubmitInfo; - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const vk::Semaphore* pWaitSemaphores; - const vk::PipelineStageFlags* pWaitDstStageMask; - uint32_t commandBufferCount; - const vk::CommandBuffer* pCommandBuffers; - uint32_t signalSemaphoreCount; - const vk::Semaphore* pSignalSemaphores; - }; - static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "layout struct and wrapper have different size!" ); - } - - struct SubmitInfo : public layout::SubmitInfo + struct SubmitInfo { VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = 0, const vk::Semaphore* pWaitSemaphores_ = nullptr, @@ -62235,16 +55768,29 @@ namespace VULKAN_HPP_NAMESPACE const vk::CommandBuffer* pCommandBuffers_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SubmitInfo( waitSemaphoreCount_, pWaitSemaphores_, pWaitDstStageMask_, commandBufferCount_, pCommandBuffers_, signalSemaphoreCount_, pSignalSemaphores_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , pWaitDstStageMask( pWaitDstStageMask_ ) + , commandBufferCount( commandBufferCount_ ) + , pCommandBuffers( pCommandBuffers_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphores( pSignalSemaphores_ ) {} + vk::SubmitInfo & operator=( vk::SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubmitInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubmitInfo( rhs ) - {} + { + *this = rhs; + } SubmitInfo& operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubmitInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62324,53 +55870,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubmitInfo::sType; + public: + const vk::StructureType sType = StructureType::eSubmitInfo; + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const vk::Semaphore* pWaitSemaphores; + const vk::PipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const vk::CommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const vk::Semaphore* pSignalSemaphores; }; static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassBeginInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT - : contents( contents_ ) - {} - - SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassBeginInfoKHR; - const void* pNext = nullptr; - vk::SubpassContents contents; - }; - static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassBeginInfoKHR : public layout::SubpassBeginInfoKHR + struct SubpassBeginInfoKHR { VULKAN_HPP_CONSTEXPR SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT - : layout::SubpassBeginInfoKHR( contents_ ) + : contents( contents_ ) {} + vk::SubpassBeginInfoKHR & operator=( vk::SubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassBeginInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassBeginInfoKHR( rhs ) - {} + { + *this = rhs; + } SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassBeginInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62408,61 +55941,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassBeginInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassBeginInfoKHR; + const void* pNext = nullptr; + vk::SubpassContents contents; }; static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassDescriptionDepthStencilResolveKHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone, - vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone, - const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr ) VULKAN_HPP_NOEXCEPT - : depthResolveMode( depthResolveMode_ ) - , stencilResolveMode( stencilResolveMode_ ) - , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ ) - {} - - SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR; - const void* pNext = nullptr; - vk::ResolveModeFlagBitsKHR depthResolveMode; - vk::ResolveModeFlagBitsKHR stencilResolveMode; - const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment; - }; - static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassDescriptionDepthStencilResolveKHR : public layout::SubpassDescriptionDepthStencilResolveKHR + struct SubpassDescriptionDepthStencilResolveKHR { VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone, vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone, const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDescriptionDepthStencilResolveKHR( depthResolveMode_, stencilResolveMode_, pDepthStencilResolveAttachment_ ) + : depthResolveMode( depthResolveMode_ ) + , stencilResolveMode( stencilResolveMode_ ) + , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ ) {} + vk::SubpassDescriptionDepthStencilResolveKHR & operator=( vk::SubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDescriptionDepthStencilResolveKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDescriptionDepthStencilResolveKHR( rhs ) - {} + { + *this = rhs; + } SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassDescriptionDepthStencilResolveKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62514,51 +56024,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassDescriptionDepthStencilResolveKHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR; + const void* pNext = nullptr; + vk::ResolveModeFlagBitsKHR depthResolveMode; + vk::ResolveModeFlagBitsKHR stencilResolveMode; + const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment; }; static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassEndInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassEndInfoKHR() VULKAN_HPP_NOEXCEPT - {} - - SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassEndInfoKHR; - const void* pNext = nullptr; - }; - static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassEndInfoKHR : public layout::SubpassEndInfoKHR + struct SubpassEndInfoKHR { VULKAN_HPP_CONSTEXPR SubpassEndInfoKHR() VULKAN_HPP_NOEXCEPT - : layout::SubpassEndInfoKHR() {} + vk::SubpassEndInfoKHR & operator=( vk::SubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassEndInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassEndInfoKHR( rhs ) - {} + { + *this = rhs; + } SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassEndInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62589,62 +56083,53 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassEndInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassEndInfoKHR; + const void* pNext = nullptr; }; static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SurfaceCapabilities2EXT { - struct SurfaceCapabilities2EXT - { - protected: - SurfaceCapabilities2EXT() VULKAN_HPP_NOEXCEPT - {} - - SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceCapabilities2EXT; - void* pNext = nullptr; - uint32_t minImageCount; - uint32_t maxImageCount; - vk::Extent2D currentExtent; - vk::Extent2D minImageExtent; - vk::Extent2D maxImageExtent; - uint32_t maxImageArrayLayers; - vk::SurfaceTransformFlagsKHR supportedTransforms; - vk::SurfaceTransformFlagBitsKHR currentTransform; - vk::CompositeAlphaFlagsKHR supportedCompositeAlpha; - vk::ImageUsageFlags supportedUsageFlags; - vk::SurfaceCounterFlagsEXT supportedSurfaceCounters; - }; - static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceCapabilities2EXT : public layout::SurfaceCapabilities2EXT - { - SurfaceCapabilities2EXT() VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilities2EXT() + SurfaceCapabilities2EXT( uint32_t minImageCount_ = 0, + uint32_t maxImageCount_ = 0, + vk::Extent2D currentExtent_ = vk::Extent2D(), + vk::Extent2D minImageExtent_ = vk::Extent2D(), + vk::Extent2D maxImageExtent_ = vk::Extent2D(), + uint32_t maxImageArrayLayers_ = 0, + vk::SurfaceTransformFlagsKHR supportedTransforms_ = vk::SurfaceTransformFlagsKHR(), + vk::SurfaceTransformFlagBitsKHR currentTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity, + vk::CompositeAlphaFlagsKHR supportedCompositeAlpha_ = vk::CompositeAlphaFlagsKHR(), + vk::ImageUsageFlags supportedUsageFlags_ = vk::ImageUsageFlags(), + vk::SurfaceCounterFlagsEXT supportedSurfaceCounters_ = vk::SurfaceCounterFlagsEXT() ) VULKAN_HPP_NOEXCEPT + : minImageCount( minImageCount_ ) + , maxImageCount( maxImageCount_ ) + , currentExtent( currentExtent_ ) + , minImageExtent( minImageExtent_ ) + , maxImageExtent( maxImageExtent_ ) + , maxImageArrayLayers( maxImageArrayLayers_ ) + , supportedTransforms( supportedTransforms_ ) + , currentTransform( currentTransform_ ) + , supportedCompositeAlpha( supportedCompositeAlpha_ ) + , supportedUsageFlags( supportedUsageFlags_ ) + , supportedSurfaceCounters( supportedSurfaceCounters_ ) {} + vk::SurfaceCapabilities2EXT & operator=( vk::SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilities2EXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilities2EXT( rhs ) - {} + { + *this = rhs; + } SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceCapabilities2EXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62680,25 +56165,56 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceCapabilities2EXT::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceCapabilities2EXT; + void* pNext = nullptr; + uint32_t minImageCount; + uint32_t maxImageCount; + vk::Extent2D currentExtent; + vk::Extent2D minImageExtent; + vk::Extent2D maxImageExtent; + uint32_t maxImageArrayLayers; + vk::SurfaceTransformFlagsKHR supportedTransforms; + vk::SurfaceTransformFlagBitsKHR currentTransform; + vk::CompositeAlphaFlagsKHR supportedCompositeAlpha; + vk::ImageUsageFlags supportedUsageFlags; + vk::SurfaceCounterFlagsEXT supportedSurfaceCounters; }; static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct SurfaceCapabilitiesKHR { - SurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT + SurfaceCapabilitiesKHR( uint32_t minImageCount_ = 0, + uint32_t maxImageCount_ = 0, + vk::Extent2D currentExtent_ = vk::Extent2D(), + vk::Extent2D minImageExtent_ = vk::Extent2D(), + vk::Extent2D maxImageExtent_ = vk::Extent2D(), + uint32_t maxImageArrayLayers_ = 0, + vk::SurfaceTransformFlagsKHR supportedTransforms_ = vk::SurfaceTransformFlagsKHR(), + vk::SurfaceTransformFlagBitsKHR currentTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity, + vk::CompositeAlphaFlagsKHR supportedCompositeAlpha_ = vk::CompositeAlphaFlagsKHR(), + vk::ImageUsageFlags supportedUsageFlags_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT + : minImageCount( minImageCount_ ) + , maxImageCount( maxImageCount_ ) + , currentExtent( currentExtent_ ) + , minImageExtent( minImageExtent_ ) + , maxImageExtent( maxImageExtent_ ) + , maxImageArrayLayers( maxImageArrayLayers_ ) + , supportedTransforms( supportedTransforms_ ) + , currentTransform( currentTransform_ ) + , supportedCompositeAlpha( supportedCompositeAlpha_ ) + , supportedUsageFlags( supportedUsageFlags_ ) {} SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SurfaceCapabilitiesKHR& operator=( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -62746,46 +56262,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SurfaceCapabilities2KHR { - struct SurfaceCapabilities2KHR - { - protected: - SurfaceCapabilities2KHR() VULKAN_HPP_NOEXCEPT - {} - - SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceCapabilities2KHR; - void* pNext = nullptr; - vk::SurfaceCapabilitiesKHR surfaceCapabilities; - }; - static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceCapabilities2KHR : public layout::SurfaceCapabilities2KHR - { - SurfaceCapabilities2KHR() VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilities2KHR() + SurfaceCapabilities2KHR( vk::SurfaceCapabilitiesKHR surfaceCapabilities_ = vk::SurfaceCapabilitiesKHR() ) VULKAN_HPP_NOEXCEPT + : surfaceCapabilities( surfaceCapabilities_ ) {} + vk::SurfaceCapabilities2KHR & operator=( vk::SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilities2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilities2KHR( rhs ) - {} + { + *this = rhs; + } SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceCapabilities2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62811,55 +56307,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceCapabilities2KHR::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceCapabilities2KHR; + void* pNext = nullptr; + vk::SurfaceCapabilitiesKHR surfaceCapabilities; }; static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct SurfaceCapabilitiesFullScreenExclusiveEXT - { - protected: - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 ) VULKAN_HPP_NOEXCEPT - : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ ) - {} - - SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; - void* pNext = nullptr; - vk::Bool32 fullScreenExclusiveSupported; - }; - static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceCapabilitiesFullScreenExclusiveEXT : public layout::SurfaceCapabilitiesFullScreenExclusiveEXT + struct SurfaceCapabilitiesFullScreenExclusiveEXT { VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( fullScreenExclusiveSupported_ ) + : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ ) {} + vk::SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( vk::SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilitiesFullScreenExclusiveEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( rhs ) - {} + { + *this = rhs; + } SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceCapabilitiesFullScreenExclusiveEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62897,8 +56374,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceCapabilitiesFullScreenExclusiveEXT::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; + void* pNext = nullptr; + vk::Bool32 fullScreenExclusiveSupported; }; static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -62906,17 +56385,20 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceFormatKHR { - SurfaceFormatKHR() VULKAN_HPP_NOEXCEPT + SurfaceFormatKHR( vk::Format format_ = vk::Format::eUndefined, + vk::ColorSpaceKHR colorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear ) VULKAN_HPP_NOEXCEPT + : format( format_ ) + , colorSpace( colorSpace_ ) {} SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SurfaceFormatKHR& operator=( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -62948,46 +56430,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SurfaceFormat2KHR { - struct SurfaceFormat2KHR - { - protected: - SurfaceFormat2KHR() VULKAN_HPP_NOEXCEPT - {} - - SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceFormat2KHR; - void* pNext = nullptr; - vk::SurfaceFormatKHR surfaceFormat; - }; - static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceFormat2KHR : public layout::SurfaceFormat2KHR - { - SurfaceFormat2KHR() VULKAN_HPP_NOEXCEPT - : layout::SurfaceFormat2KHR() + SurfaceFormat2KHR( vk::SurfaceFormatKHR surfaceFormat_ = vk::SurfaceFormatKHR() ) VULKAN_HPP_NOEXCEPT + : surfaceFormat( surfaceFormat_ ) {} + vk::SurfaceFormat2KHR & operator=( vk::SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFormat2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFormat2KHR( rhs ) - {} + { + *this = rhs; + } SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceFormat2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63013,55 +56475,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceFormat2KHR::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceFormat2KHR; + void* pNext = nullptr; + vk::SurfaceFormatKHR surfaceFormat; }; static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct SurfaceFullScreenExclusiveInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT - : fullScreenExclusive( fullScreenExclusive_ ) - {} - - SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; - void* pNext = nullptr; - vk::FullScreenExclusiveEXT fullScreenExclusive; - }; - static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceFullScreenExclusiveInfoEXT : public layout::SurfaceFullScreenExclusiveInfoEXT + struct SurfaceFullScreenExclusiveInfoEXT { VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFullScreenExclusiveInfoEXT( fullScreenExclusive_ ) + : fullScreenExclusive( fullScreenExclusive_ ) {} + vk::SurfaceFullScreenExclusiveInfoEXT & operator=( vk::SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFullScreenExclusiveInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFullScreenExclusiveInfoEXT( rhs ) - {} + { + *this = rhs; + } SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceFullScreenExclusiveInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63099,8 +56542,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceFullScreenExclusiveInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; + void* pNext = nullptr; + vk::FullScreenExclusiveEXT fullScreenExclusive; }; static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -63108,47 +56553,26 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct SurfaceFullScreenExclusiveWin32InfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 ) VULKAN_HPP_NOEXCEPT - : hmonitor( hmonitor_ ) - {} - - SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; - const void* pNext = nullptr; - HMONITOR hmonitor; - }; - static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceFullScreenExclusiveWin32InfoEXT : public layout::SurfaceFullScreenExclusiveWin32InfoEXT + struct SurfaceFullScreenExclusiveWin32InfoEXT { VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFullScreenExclusiveWin32InfoEXT( hmonitor_ ) + : hmonitor( hmonitor_ ) {} + vk::SurfaceFullScreenExclusiveWin32InfoEXT & operator=( vk::SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFullScreenExclusiveWin32InfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFullScreenExclusiveWin32InfoEXT( rhs ) - {} + { + *this = rhs; + } SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceFullScreenExclusiveWin32InfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63186,54 +56610,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceFullScreenExclusiveWin32InfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; + const void* pNext = nullptr; + HMONITOR hmonitor; }; static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct SurfaceProtectedCapabilitiesKHR - { - protected: - VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 ) VULKAN_HPP_NOEXCEPT - : supportsProtected( supportsProtected_ ) - {} - - SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; - const void* pNext = nullptr; - vk::Bool32 supportsProtected; - }; - static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceProtectedCapabilitiesKHR : public layout::SurfaceProtectedCapabilitiesKHR + struct SurfaceProtectedCapabilitiesKHR { VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceProtectedCapabilitiesKHR( supportsProtected_ ) + : supportsProtected( supportsProtected_ ) {} + vk::SurfaceProtectedCapabilitiesKHR & operator=( vk::SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceProtectedCapabilitiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceProtectedCapabilitiesKHR( rhs ) - {} + { + *this = rhs; + } SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceProtectedCapabilitiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63271,53 +56676,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceProtectedCapabilitiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; + const void* pNext = nullptr; + vk::Bool32 supportsProtected; }; static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SwapchainCounterCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : surfaceCounters( surfaceCounters_ ) - {} - - SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; - const void* pNext = nullptr; - vk::SurfaceCounterFlagsEXT surfaceCounters; - }; - static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SwapchainCounterCreateInfoEXT : public layout::SwapchainCounterCreateInfoEXT + struct SwapchainCounterCreateInfoEXT { VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainCounterCreateInfoEXT( surfaceCounters_ ) + : surfaceCounters( surfaceCounters_ ) {} + vk::SwapchainCounterCreateInfoEXT & operator=( vk::SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainCounterCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainCounterCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SwapchainCounterCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63355,86 +56741,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SwapchainCounterCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; + const void* pNext = nullptr; + vk::SurfaceCounterFlagsEXT surfaceCounters; }; static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SwapchainCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(), - vk::SurfaceKHR surface_ = vk::SurfaceKHR(), - uint32_t minImageCount_ = 0, - vk::Format imageFormat_ = vk::Format::eUndefined, - vk::ColorSpaceKHR imageColorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear, - vk::Extent2D imageExtent_ = vk::Extent2D(), - uint32_t imageArrayLayers_ = 0, - vk::ImageUsageFlags imageUsage_ = vk::ImageUsageFlags(), - vk::SharingMode imageSharingMode_ = vk::SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr, - vk::SurfaceTransformFlagBitsKHR preTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity, - vk::CompositeAlphaFlagBitsKHR compositeAlpha_ = vk::CompositeAlphaFlagBitsKHR::eOpaque, - vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate, - vk::Bool32 clipped_ = 0, - vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , surface( surface_ ) - , minImageCount( minImageCount_ ) - , imageFormat( imageFormat_ ) - , imageColorSpace( imageColorSpace_ ) - , imageExtent( imageExtent_ ) - , imageArrayLayers( imageArrayLayers_ ) - , imageUsage( imageUsage_ ) - , imageSharingMode( imageSharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , preTransform( preTransform_ ) - , compositeAlpha( compositeAlpha_ ) - , presentMode( presentMode_ ) - , clipped( clipped_ ) - , oldSwapchain( oldSwapchain_ ) - {} - - SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSwapchainCreateInfoKHR; - const void* pNext = nullptr; - vk::SwapchainCreateFlagsKHR flags; - vk::SurfaceKHR surface; - uint32_t minImageCount; - vk::Format imageFormat; - vk::ColorSpaceKHR imageColorSpace; - vk::Extent2D imageExtent; - uint32_t imageArrayLayers; - vk::ImageUsageFlags imageUsage; - vk::SharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - vk::SurfaceTransformFlagBitsKHR preTransform; - vk::CompositeAlphaFlagBitsKHR compositeAlpha; - vk::PresentModeKHR presentMode; - vk::Bool32 clipped; - vk::SwapchainKHR oldSwapchain; - }; - static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SwapchainCreateInfoKHR : public layout::SwapchainCreateInfoKHR + struct SwapchainCreateInfoKHR { VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(), vk::SurfaceKHR surface_ = vk::SurfaceKHR(), @@ -63452,16 +56767,38 @@ namespace VULKAN_HPP_NAMESPACE vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate, vk::Bool32 clipped_ = 0, vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainCreateInfoKHR( flags_, surface_, minImageCount_, imageFormat_, imageColorSpace_, imageExtent_, imageArrayLayers_, imageUsage_, imageSharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, preTransform_, compositeAlpha_, presentMode_, clipped_, oldSwapchain_ ) + : flags( flags_ ) + , surface( surface_ ) + , minImageCount( minImageCount_ ) + , imageFormat( imageFormat_ ) + , imageColorSpace( imageColorSpace_ ) + , imageExtent( imageExtent_ ) + , imageArrayLayers( imageArrayLayers_ ) + , imageUsage( imageUsage_ ) + , imageSharingMode( imageSharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + , preTransform( preTransform_ ) + , compositeAlpha( compositeAlpha_ ) + , presentMode( presentMode_ ) + , clipped( clipped_ ) + , oldSwapchain( oldSwapchain_ ) {} + vk::SwapchainCreateInfoKHR & operator=( vk::SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SwapchainCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63604,53 +56941,49 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SwapchainCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSwapchainCreateInfoKHR; + const void* pNext = nullptr; + vk::SwapchainCreateFlagsKHR flags; + vk::SurfaceKHR surface; + uint32_t minImageCount; + vk::Format imageFormat; + vk::ColorSpaceKHR imageColorSpace; + vk::Extent2D imageExtent; + uint32_t imageArrayLayers; + vk::ImageUsageFlags imageUsage; + vk::SharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + vk::SurfaceTransformFlagBitsKHR preTransform; + vk::CompositeAlphaFlagBitsKHR compositeAlpha; + vk::PresentModeKHR presentMode; + vk::Bool32 clipped; + vk::SwapchainKHR oldSwapchain; }; static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SwapchainDisplayNativeHdrCreateInfoAMD - { - protected: - VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : localDimmingEnable( localDimmingEnable_ ) - {} - - SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; - const void* pNext = nullptr; - vk::Bool32 localDimmingEnable; - }; - static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "layout struct and wrapper have different size!" ); - } - - struct SwapchainDisplayNativeHdrCreateInfoAMD : public layout::SwapchainDisplayNativeHdrCreateInfoAMD + struct SwapchainDisplayNativeHdrCreateInfoAMD { VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainDisplayNativeHdrCreateInfoAMD( localDimmingEnable_ ) + : localDimmingEnable( localDimmingEnable_ ) {} + vk::SwapchainDisplayNativeHdrCreateInfoAMD & operator=( vk::SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainDisplayNativeHdrCreateInfoAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainDisplayNativeHdrCreateInfoAMD( rhs ) - {} + { + *this = rhs; + } SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SwapchainDisplayNativeHdrCreateInfoAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63688,52 +57021,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SwapchainDisplayNativeHdrCreateInfoAMD::sType; + public: + const vk::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; + const void* pNext = nullptr; + vk::Bool32 localDimmingEnable; }; static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct TextureLODGatherFormatPropertiesAMD { - struct TextureLODGatherFormatPropertiesAMD - { - protected: - TextureLODGatherFormatPropertiesAMD() VULKAN_HPP_NOEXCEPT - {} - - TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; - void* pNext = nullptr; - vk::Bool32 supportsTextureGatherLODBiasAMD; - }; - static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "layout struct and wrapper have different size!" ); - } - - struct TextureLODGatherFormatPropertiesAMD : public layout::TextureLODGatherFormatPropertiesAMD - { - TextureLODGatherFormatPropertiesAMD() VULKAN_HPP_NOEXCEPT - : layout::TextureLODGatherFormatPropertiesAMD() + TextureLODGatherFormatPropertiesAMD( vk::Bool32 supportsTextureGatherLODBiasAMD_ = 0 ) VULKAN_HPP_NOEXCEPT + : supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ ) {} + vk::TextureLODGatherFormatPropertiesAMD & operator=( vk::TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::TextureLODGatherFormatPropertiesAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::TextureLODGatherFormatPropertiesAMD( rhs ) - {} + { + *this = rhs; + } TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::TextureLODGatherFormatPropertiesAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63759,65 +57074,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::TextureLODGatherFormatPropertiesAMD::sType; + public: + const vk::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; + void* pNext = nullptr; + vk::Bool32 supportsTextureGatherLODBiasAMD; }; static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct TimelineSemaphoreSubmitInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfoKHR( uint32_t waitSemaphoreValueCount_ = 0, - const uint64_t* pWaitSemaphoreValues_ = nullptr, - uint32_t signalSemaphoreValueCount_ = 0, - const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreValueCount( waitSemaphoreValueCount_ ) - , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) - , signalSemaphoreValueCount( signalSemaphoreValueCount_ ) - , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) - {} - - TimelineSemaphoreSubmitInfoKHR( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfoKHR; - const void* pNext = nullptr; - uint32_t waitSemaphoreValueCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValueCount; - const uint64_t* pSignalSemaphoreValues; - }; - static_assert( sizeof( TimelineSemaphoreSubmitInfoKHR ) == sizeof( VkTimelineSemaphoreSubmitInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct TimelineSemaphoreSubmitInfoKHR : public layout::TimelineSemaphoreSubmitInfoKHR + struct TimelineSemaphoreSubmitInfoKHR { VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfoKHR( uint32_t waitSemaphoreValueCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValueCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::TimelineSemaphoreSubmitInfoKHR( waitSemaphoreValueCount_, pWaitSemaphoreValues_, signalSemaphoreValueCount_, pSignalSemaphoreValues_ ) + : waitSemaphoreValueCount( waitSemaphoreValueCount_ ) + , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) + , signalSemaphoreValueCount( signalSemaphoreValueCount_ ) + , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) {} + vk::TimelineSemaphoreSubmitInfoKHR & operator=( vk::TimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::TimelineSemaphoreSubmitInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + TimelineSemaphoreSubmitInfoKHR( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::TimelineSemaphoreSubmitInfoKHR( rhs ) - {} + { + *this = rhs; + } TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::TimelineSemaphoreSubmitInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63876,61 +57166,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::TimelineSemaphoreSubmitInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfoKHR; + const void* pNext = nullptr; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues; }; static_assert( sizeof( TimelineSemaphoreSubmitInfoKHR ) == sizeof( VkTimelineSemaphoreSubmitInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ValidationCacheCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(), - size_t initialDataSize_ = 0, - const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , initialDataSize( initialDataSize_ ) - , pInitialData( pInitialData_ ) - {} - - ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eValidationCacheCreateInfoEXT; - const void* pNext = nullptr; - vk::ValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void* pInitialData; - }; - static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ValidationCacheCreateInfoEXT : public layout::ValidationCacheCreateInfoEXT + struct ValidationCacheCreateInfoEXT { VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ValidationCacheCreateInfoEXT( flags_, initialDataSize_, pInitialData_ ) + : flags( flags_ ) + , initialDataSize( initialDataSize_ ) + , pInitialData( pInitialData_ ) {} + vk::ValidationCacheCreateInfoEXT & operator=( vk::ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationCacheCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ValidationCacheCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ValidationCacheCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63982,65 +57252,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ValidationCacheCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eValidationCacheCreateInfoEXT; + const void* pNext = nullptr; + vk::ValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData; }; static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ValidationFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0, - const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr, - uint32_t disabledValidationFeatureCount_ = 0, - const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : enabledValidationFeatureCount( enabledValidationFeatureCount_ ) - , pEnabledValidationFeatures( pEnabledValidationFeatures_ ) - , disabledValidationFeatureCount( disabledValidationFeatureCount_ ) - , pDisabledValidationFeatures( pDisabledValidationFeatures_ ) - {} - - ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eValidationFeaturesEXT; - const void* pNext = nullptr; - uint32_t enabledValidationFeatureCount; - const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures; - uint32_t disabledValidationFeatureCount; - const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures; - }; - static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct ValidationFeaturesEXT : public layout::ValidationFeaturesEXT + struct ValidationFeaturesEXT { VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0, const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr, uint32_t disabledValidationFeatureCount_ = 0, const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ValidationFeaturesEXT( enabledValidationFeatureCount_, pEnabledValidationFeatures_, disabledValidationFeatureCount_, pDisabledValidationFeatures_ ) + : enabledValidationFeatureCount( enabledValidationFeatureCount_ ) + , pEnabledValidationFeatures( pEnabledValidationFeatures_ ) + , disabledValidationFeatureCount( disabledValidationFeatureCount_ ) + , pDisabledValidationFeatures( pDisabledValidationFeatures_ ) {} + vk::ValidationFeaturesEXT & operator=( vk::ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ValidationFeaturesEXT( rhs ) - {} + { + *this = rhs; + } ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ValidationFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64099,57 +57346,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ValidationFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::eValidationFeaturesEXT; + const void* pNext = nullptr; + uint32_t enabledValidationFeatureCount; + const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures; }; static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ValidationFlagsEXT - { - protected: - VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, - const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : disabledValidationCheckCount( disabledValidationCheckCount_ ) - , pDisabledValidationChecks( pDisabledValidationChecks_ ) - {} - - ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eValidationFlagsEXT; - const void* pNext = nullptr; - uint32_t disabledValidationCheckCount; - const vk::ValidationCheckEXT* pDisabledValidationChecks; - }; - static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "layout struct and wrapper have different size!" ); - } - - struct ValidationFlagsEXT : public layout::ValidationFlagsEXT + struct ValidationFlagsEXT { VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ValidationFlagsEXT( disabledValidationCheckCount_, pDisabledValidationChecks_ ) + : disabledValidationCheckCount( disabledValidationCheckCount_ ) + , pDisabledValidationChecks( pDisabledValidationChecks_ ) {} + vk::ValidationFlagsEXT & operator=( vk::ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationFlagsEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ValidationFlagsEXT( rhs ) - {} + { + *this = rhs; + } ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ValidationFlagsEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64194,59 +57423,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ValidationFlagsEXT::sType; + public: + const vk::StructureType sType = StructureType::eValidationFlagsEXT; + const void* pNext = nullptr; + uint32_t disabledValidationCheckCount; + const vk::ValidationCheckEXT* pDisabledValidationChecks; }; static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_VI_NN - namespace layout - { - struct ViSurfaceCreateInfoNN - { - protected: - VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(), - void* window_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , window( window_ ) - {} - - ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eViSurfaceCreateInfoNN; - const void* pNext = nullptr; - vk::ViSurfaceCreateFlagsNN flags; - void* window; - }; - static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "layout struct and wrapper have different size!" ); - } - - struct ViSurfaceCreateInfoNN : public layout::ViSurfaceCreateInfoNN + struct ViSurfaceCreateInfoNN { VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(), void* window_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ViSurfaceCreateInfoNN( flags_, window_ ) + : flags( flags_ ) + , window( window_ ) {} + vk::ViSurfaceCreateInfoNN & operator=( vk::ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ViSurfaceCreateInfoNN ) - sizeof( vk::StructureType ) ); + return *this; + } + ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ViSurfaceCreateInfoNN( rhs ) - {} + { + *this = rhs; + } ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ViSurfaceCreateInfoNN::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64291,8 +57500,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ViSurfaceCreateInfoNN::sType; + public: + const vk::StructureType sType = StructureType::eViSurfaceCreateInfoNN; + const void* pNext = nullptr; + vk::ViSurfaceCreateFlagsNN flags; + void* window; }; static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -64300,55 +57512,30 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WAYLAND_KHR - namespace layout - { - struct WaylandSurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(), - struct wl_display* display_ = nullptr, - struct wl_surface* surface_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , display( display_ ) - , surface( surface_ ) - {} - - WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::WaylandSurfaceCreateFlagsKHR flags; - struct wl_display* display; - struct wl_surface* surface; - }; - static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct WaylandSurfaceCreateInfoKHR : public layout::WaylandSurfaceCreateInfoKHR + struct WaylandSurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(), struct wl_display* display_ = nullptr, struct wl_surface* surface_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::WaylandSurfaceCreateInfoKHR( flags_, display_, surface_ ) + : flags( flags_ ) + , display( display_ ) + , surface( surface_ ) {} + vk::WaylandSurfaceCreateInfoKHR & operator=( vk::WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::WaylandSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::WaylandSurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::WaylandSurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64400,8 +57587,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::WaylandSurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::WaylandSurfaceCreateFlagsKHR flags; + struct wl_display* display; + struct wl_surface* surface; }; static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -64409,53 +57600,7 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct Win32KeyedMutexAcquireReleaseInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, - const vk::DeviceMemory* pAcquireSyncs_ = nullptr, - const uint64_t* pAcquireKeys_ = nullptr, - const uint32_t* pAcquireTimeouts_ = nullptr, - uint32_t releaseCount_ = 0, - const vk::DeviceMemory* pReleaseSyncs_ = nullptr, - const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT - : acquireCount( acquireCount_ ) - , pAcquireSyncs( pAcquireSyncs_ ) - , pAcquireKeys( pAcquireKeys_ ) - , pAcquireTimeouts( pAcquireTimeouts_ ) - , releaseCount( releaseCount_ ) - , pReleaseSyncs( pReleaseSyncs_ ) - , pReleaseKeys( pReleaseKeys_ ) - {} - - Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; - const void* pNext = nullptr; - uint32_t acquireCount; - const vk::DeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeouts; - uint32_t releaseCount; - const vk::DeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; - }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct Win32KeyedMutexAcquireReleaseInfoKHR : public layout::Win32KeyedMutexAcquireReleaseInfoKHR + struct Win32KeyedMutexAcquireReleaseInfoKHR { VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const vk::DeviceMemory* pAcquireSyncs_ = nullptr, @@ -64464,16 +57609,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t releaseCount_ = 0, const vk::DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::Win32KeyedMutexAcquireReleaseInfoKHR( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeouts_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ ) + : acquireCount( acquireCount_ ) + , pAcquireSyncs( pAcquireSyncs_ ) + , pAcquireKeys( pAcquireKeys_ ) + , pAcquireTimeouts( pAcquireTimeouts_ ) + , releaseCount( releaseCount_ ) + , pReleaseSyncs( pReleaseSyncs_ ) + , pReleaseKeys( pReleaseKeys_ ) {} + vk::Win32KeyedMutexAcquireReleaseInfoKHR & operator=( vk::Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32KeyedMutexAcquireReleaseInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::Win32KeyedMutexAcquireReleaseInfoKHR( rhs ) - {} + { + *this = rhs; + } Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::Win32KeyedMutexAcquireReleaseInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64553,8 +57711,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::Win32KeyedMutexAcquireReleaseInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; + const void* pNext = nullptr; + uint32_t acquireCount; + const vk::DeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const vk::DeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; }; static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -64562,53 +57728,7 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct Win32KeyedMutexAcquireReleaseInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, - const vk::DeviceMemory* pAcquireSyncs_ = nullptr, - const uint64_t* pAcquireKeys_ = nullptr, - const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, - uint32_t releaseCount_ = 0, - const vk::DeviceMemory* pReleaseSyncs_ = nullptr, - const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT - : acquireCount( acquireCount_ ) - , pAcquireSyncs( pAcquireSyncs_ ) - , pAcquireKeys( pAcquireKeys_ ) - , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ) - , releaseCount( releaseCount_ ) - , pReleaseSyncs( pReleaseSyncs_ ) - , pReleaseKeys( pReleaseKeys_ ) - {} - - Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; - const void* pNext = nullptr; - uint32_t acquireCount; - const vk::DeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeoutMilliseconds; - uint32_t releaseCount; - const vk::DeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; - }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct Win32KeyedMutexAcquireReleaseInfoNV : public layout::Win32KeyedMutexAcquireReleaseInfoNV + struct Win32KeyedMutexAcquireReleaseInfoNV { VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const vk::DeviceMemory* pAcquireSyncs_ = nullptr, @@ -64617,16 +57737,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t releaseCount_ = 0, const vk::DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::Win32KeyedMutexAcquireReleaseInfoNV( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeoutMilliseconds_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ ) + : acquireCount( acquireCount_ ) + , pAcquireSyncs( pAcquireSyncs_ ) + , pAcquireKeys( pAcquireKeys_ ) + , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ) + , releaseCount( releaseCount_ ) + , pReleaseSyncs( pReleaseSyncs_ ) + , pReleaseKeys( pReleaseKeys_ ) {} + vk::Win32KeyedMutexAcquireReleaseInfoNV & operator=( vk::Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32KeyedMutexAcquireReleaseInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::Win32KeyedMutexAcquireReleaseInfoNV( rhs ) - {} + { + *this = rhs; + } Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::Win32KeyedMutexAcquireReleaseInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64706,8 +57839,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::Win32KeyedMutexAcquireReleaseInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; + const void* pNext = nullptr; + uint32_t acquireCount; + const vk::DeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeoutMilliseconds; + uint32_t releaseCount; + const vk::DeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; }; static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -64715,55 +57856,30 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct Win32SurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(), - HINSTANCE hinstance_ = 0, - HWND hwnd_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , hinstance( hinstance_ ) - , hwnd( hwnd_ ) - {} - - Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::Win32SurfaceCreateFlagsKHR flags; - HINSTANCE hinstance; - HWND hwnd; - }; - static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct Win32SurfaceCreateInfoKHR : public layout::Win32SurfaceCreateInfoKHR + struct Win32SurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(), HINSTANCE hinstance_ = 0, HWND hwnd_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::Win32SurfaceCreateInfoKHR( flags_, hinstance_, hwnd_ ) + : flags( flags_ ) + , hinstance( hinstance_ ) + , hwnd( hwnd_ ) {} + vk::Win32SurfaceCreateInfoKHR & operator=( vk::Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32SurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::Win32SurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::Win32SurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64815,63 +57931,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::Win32SurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::Win32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; }; static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct WriteDescriptorSet - { - protected: - VULKAN_HPP_CONSTEXPR WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(), - uint32_t dstBinding_ = 0, - uint32_t dstArrayElement_ = 0, - uint32_t descriptorCount_ = 0, - vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler, - const vk::DescriptorImageInfo* pImageInfo_ = nullptr, - const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr, - const vk::BufferView* pTexelBufferView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - , descriptorType( descriptorType_ ) - , pImageInfo( pImageInfo_ ) - , pBufferInfo( pBufferInfo_ ) - , pTexelBufferView( pTexelBufferView_ ) - {} - - WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWriteDescriptorSet; - const void* pNext = nullptr; - vk::DescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - vk::DescriptorType descriptorType; - const vk::DescriptorImageInfo* pImageInfo; - const vk::DescriptorBufferInfo* pBufferInfo; - const vk::BufferView* pTexelBufferView; - }; - static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "layout struct and wrapper have different size!" ); - } - - struct WriteDescriptorSet : public layout::WriteDescriptorSet + struct WriteDescriptorSet { VULKAN_HPP_CONSTEXPR WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(), uint32_t dstBinding_ = 0, @@ -64881,16 +57952,30 @@ namespace VULKAN_HPP_NAMESPACE const vk::DescriptorImageInfo* pImageInfo_ = nullptr, const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr, const vk::BufferView* pTexelBufferView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSet( dstSet_, dstBinding_, dstArrayElement_, descriptorCount_, descriptorType_, pImageInfo_, pBufferInfo_, pTexelBufferView_ ) + : dstSet( dstSet_ ) + , dstBinding( dstBinding_ ) + , dstArrayElement( dstArrayElement_ ) + , descriptorCount( descriptorCount_ ) + , descriptorType( descriptorType_ ) + , pImageInfo( pImageInfo_ ) + , pBufferInfo( pBufferInfo_ ) + , pTexelBufferView( pTexelBufferView_ ) {} + vk::WriteDescriptorSet & operator=( vk::WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSet ) - sizeof( vk::StructureType ) ); + return *this; + } + WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSet( rhs ) - {} + { + *this = rhs; + } WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::WriteDescriptorSet::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64977,57 +58062,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::WriteDescriptorSet::sType; + public: + const vk::StructureType sType = StructureType::eWriteDescriptorSet; + const void* pNext = nullptr; + vk::DescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + vk::DescriptorType descriptorType; + const vk::DescriptorImageInfo* pImageInfo; + const vk::DescriptorBufferInfo* pBufferInfo; + const vk::BufferView* pTexelBufferView; }; static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct WriteDescriptorSetAccelerationStructureNV - { - protected: - VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0, - const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : accelerationStructureCount( accelerationStructureCount_ ) - , pAccelerationStructures( pAccelerationStructures_ ) - {} - - WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV; - const void* pNext = nullptr; - uint32_t accelerationStructureCount; - const vk::AccelerationStructureNV* pAccelerationStructures; - }; - static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "layout struct and wrapper have different size!" ); - } - - struct WriteDescriptorSetAccelerationStructureNV : public layout::WriteDescriptorSetAccelerationStructureNV + struct WriteDescriptorSetAccelerationStructureNV { VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0, const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSetAccelerationStructureNV( accelerationStructureCount_, pAccelerationStructures_ ) + : accelerationStructureCount( accelerationStructureCount_ ) + , pAccelerationStructures( pAccelerationStructures_ ) {} + vk::WriteDescriptorSetAccelerationStructureNV & operator=( vk::WriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSetAccelerationStructureNV ) - sizeof( vk::StructureType ) ); + return *this; + } + WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSetAccelerationStructureNV( rhs ) - {} + { + *this = rhs; + } WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::WriteDescriptorSetAccelerationStructureNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65072,57 +58143,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::WriteDescriptorSetAccelerationStructureNV::sType; + public: + const vk::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV; + const void* pNext = nullptr; + uint32_t accelerationStructureCount; + const vk::AccelerationStructureNV* pAccelerationStructures; }; static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct WriteDescriptorSetInlineUniformBlockEXT - { - protected: - VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0, - const void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : dataSize( dataSize_ ) - , pData( pData_ ) - {} - - WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT; - const void* pNext = nullptr; - uint32_t dataSize; - const void* pData; - }; - static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "layout struct and wrapper have different size!" ); - } - - struct WriteDescriptorSetInlineUniformBlockEXT : public layout::WriteDescriptorSetInlineUniformBlockEXT + struct WriteDescriptorSetInlineUniformBlockEXT { VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0, const void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSetInlineUniformBlockEXT( dataSize_, pData_ ) + : dataSize( dataSize_ ) + , pData( pData_ ) {} + vk::WriteDescriptorSetInlineUniformBlockEXT & operator=( vk::WriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSetInlineUniformBlockEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSetInlineUniformBlockEXT( rhs ) - {} + { + *this = rhs; + } WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::WriteDescriptorSetInlineUniformBlockEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65167,63 +58218,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::WriteDescriptorSetInlineUniformBlockEXT::sType; + public: + const vk::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT; + const void* pNext = nullptr; + uint32_t dataSize; + const void* pData; }; static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_XCB_KHR - namespace layout - { - struct XcbSurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(), - xcb_connection_t* connection_ = nullptr, - xcb_window_t window_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , connection( connection_ ) - , window( window_ ) - {} - - XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::XcbSurfaceCreateFlagsKHR flags; - xcb_connection_t* connection; - xcb_window_t window; - }; - static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct XcbSurfaceCreateInfoKHR : public layout::XcbSurfaceCreateInfoKHR + struct XcbSurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(), xcb_connection_t* connection_ = nullptr, xcb_window_t window_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::XcbSurfaceCreateInfoKHR( flags_, connection_, window_ ) + : flags( flags_ ) + , connection( connection_ ) + , window( window_ ) {} + vk::XcbSurfaceCreateInfoKHR & operator=( vk::XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::XcbSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::XcbSurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::XcbSurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65275,8 +58304,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::XcbSurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::XcbSurfaceCreateFlagsKHR flags; + xcb_connection_t* connection; + xcb_window_t window; }; static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -65284,55 +58317,30 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_XLIB_KHR - namespace layout - { - struct XlibSurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(), - Display* dpy_ = nullptr, - Window window_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , dpy( dpy_ ) - , window( window_ ) - {} - - XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::XlibSurfaceCreateFlagsKHR flags; - Display* dpy; - Window window; - }; - static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct XlibSurfaceCreateInfoKHR : public layout::XlibSurfaceCreateInfoKHR + struct XlibSurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(), Display* dpy_ = nullptr, Window window_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::XlibSurfaceCreateInfoKHR( flags_, dpy_, window_ ) + : flags( flags_ ) + , dpy( dpy_ ) + , window( window_ ) {} + vk::XlibSurfaceCreateInfoKHR & operator=( vk::XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::XlibSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::XlibSurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::XlibSurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65384,8 +58392,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::XlibSurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::XlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; }; static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" );