From c548ea4bf22f5bd811ffa917b0598977738a9639 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= Date: Fri, 5 Jan 2018 09:25:38 +0100 Subject: [PATCH] Remove constructors for "returnedonly" structures; introduce member inialization for pNext and sType, instead. (#168) --- VulkanHppGenerator.cpp | 130 +-- vulkan/vulkan.hpp | 2330 ++++++++++------------------------------ 2 files changed, 628 insertions(+), 1832 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index b7d954b..cbd0beb 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -3954,43 +3954,40 @@ void VulkanHppGenerator::writeStructConstructor(std::ostream & os, std::string c // the constructor with all the elements as arguments, with defaults os << " " << name << "( "; bool listedArgument = false; - if (!structData.returnedOnly) + for (size_t i = 0; i < structData.members.size(); i++) { - for (size_t i = 0; i < structData.members.size(); i++) + if (listedArgument) { - if (listedArgument) - { - os << ", "; - } - // skip members 'pNext' and 'sType', as they are never explicitly set - if ((structData.members[i].name != "pNext") && (structData.members[i].name != "sType")) - { - // find a default value for the given pure type - std::map::const_iterator defaultIt = defaultValues.find(structData.members[i].pureType); - assert(defaultIt != defaultValues.end()); + os << ", "; + } + // skip members 'pNext' and 'sType', as they are never explicitly set + if ((structData.members[i].name != "pNext") && (structData.members[i].name != "sType")) + { + // find a default value for the given pure type + std::map::const_iterator defaultIt = defaultValues.find(structData.members[i].pureType); + assert(defaultIt != defaultValues.end()); - if (structData.members[i].arraySize.empty()) - { - // the arguments name get a trailing '_', to distinguish them from the actual struct members - // pointer arguments get a nullptr as default - os << structData.members[i].type << " " << structData.members[i].name << "_ = " << (structData.members[i].type.back() == '*' ? "nullptr" : defaultIt->second); - } - else - { - // array members are provided as const reference to a std::array - // the arguments name get a trailing '_', to distinguish them from the actual struct members - // list as many default values as there are elements in the array - os << "std::array<" << structData.members[i].type << "," << structData.members[i].arraySize << "> const& " << structData.members[i].name << "_ = { { " << defaultIt->second; - size_t n = atoi(structData.members[i].arraySize.c_str()); - assert(0 < n); - for (size_t j = 1; j < n; j++) - { - os << ", " << defaultIt->second; - } - os << " } }"; - } - listedArgument = true; + if (structData.members[i].arraySize.empty()) + { + // the arguments name get a trailing '_', to distinguish them from the actual struct members + // pointer arguments get a nullptr as default + os << structData.members[i].type << " " << structData.members[i].name << "_ = " << (structData.members[i].type.back() == '*' ? "nullptr" : defaultIt->second); } + else + { + // array members are provided as const reference to a std::array + // the arguments name get a trailing '_', to distinguish them from the actual struct members + // list as many default values as there are elements in the array + os << "std::array<" << structData.members[i].type << "," << structData.members[i].arraySize << "> const& " << structData.members[i].name << "_ = { { " << defaultIt->second; + size_t n = atoi(structData.members[i].arraySize.c_str()); + assert(0 < n); + for (size_t j = 1; j < n; j++) + { + os << ", " << defaultIt->second; + } + os << " } }"; + } + listedArgument = true; } } os << " )" << std::endl; @@ -3999,38 +3996,15 @@ void VulkanHppGenerator::writeStructConstructor(std::ostream & os, std::string c bool firstArgument = true; for (size_t i = 0; i < structData.members.size(); i++) { - if (structData.members[i].arraySize.empty()) + // skip members 'pNext' and 'sType' are directly set by initializers + if ((structData.members[i].name != "pNext") && (structData.members[i].name != "sType") && (structData.members[i].arraySize.empty())) { // here, we can only handle non-array arguments std::string templateString = " ${sep} ${member}( ${value} )\n"; std::string sep = firstArgument ? ":" : ","; std::string member = structData.members[i].name; - std::string value; + std::string value = structData.members[i].name + "_"; // the elements are initialized by the corresponding argument (with trailing '_', as mentioned above) - // 'pNext' and 'sType' don't get an argument, use nullptr and the correct StructureType enum value to initialize them - if (structData.members[i].name == "pNext") - { - value = "nullptr"; - } - else if (structData.members[i].name == "sType") - { - assert(!structData.members[i].values.empty()); - auto nameIt = m_nameMap.find(structData.members[i].values); - assert(nameIt != m_nameMap.end()); - value = nameIt->second; - } - else - { - if (!structData.returnedOnly) - { - // the other elements are initialized by the corresponding argument (with trailing '_', as mentioned above) - value = structData.members[i].name + "_"; - } - else - { - templateString = ""; - } - } os << replaceWithMap(templateString, { { "sep", sep },{ "member", member },{ "value", value } }); firstArgument = false; } @@ -4038,20 +4012,17 @@ void VulkanHppGenerator::writeStructConstructor(std::ostream & os, std::string c // the body of the constructor, copying over data from argument list into wrapped struct os << " {" << std::endl; - if (!structData.returnedOnly) + for (size_t i = 0; i < structData.members.size(); i++) { - for (size_t i = 0; i < structData.members.size(); i++) + if (!structData.members[i].arraySize.empty()) { - if (!structData.members[i].arraySize.empty()) - { - // here we can handle the arrays, copying over from argument (with trailing '_') to member - // size is arraySize times sizeof type - std::string member = structData.members[i].name; - std::string arraySize = structData.members[i].arraySize; - std::string type = structData.members[i].type; - os << replaceWithMap(" memcpy( &${member}, ${member}_.data(), ${arraySize} * sizeof( ${type} ) );\n", - { { "member", member },{ "arraySize", arraySize },{ "type", type } }); - } + // here we can handle the arrays, copying over from argument (with trailing '_') to member + // size is arraySize times sizeof type + std::string member = structData.members[i].name; + std::string arraySize = structData.members[i].arraySize; + std::string type = structData.members[i].type; + os << replaceWithMap(" memcpy( &${member}, ${member}_.data(), ${arraySize} * sizeof( ${type} ) );\n", + { { "member", member },{ "arraySize", arraySize },{ "type", type } }); } } os << " }\n\n"; @@ -4536,7 +4507,11 @@ void VulkanHppGenerator::writeTypeStruct(std::ostream & os, DependencyData const os << " struct " << dependencyData.name << std::endl << " {" << std::endl; - writeStructConstructor(os, dependencyData.name, it->second, defaultValues); + // only structs that are not returnedOnly get a constructor! + if (!it->second.returnedOnly) + { + writeStructConstructor(os, dependencyData.name, it->second, defaultValues); + } // create the setters if (!it->second.returnedOnly) @@ -4593,15 +4568,22 @@ void VulkanHppGenerator::writeTypeStruct(std::ostream & os, DependencyData const if (it->second.members[i].type == "StructureType") { assert((i == 0) && (it->second.members[i].name == "sType")); + assert(!it->second.members[i].values.empty()); + auto nameIt = m_nameMap.find(it->second.members[i].values); + assert(nameIt != m_nameMap.end()); os << " private:" << std::endl - << " StructureType sType;" << std::endl + << " StructureType sType = " << nameIt->second << ";" << std::endl << std::endl << " public:" << std::endl; } else { os << " " << it->second.members[i].type << " " << it->second.members[i].name; - if (!it->second.members[i].arraySize.empty()) + if (it->second.members[i].name == "pNext") + { + os << " = nullptr"; + } + else if (!it->second.members[i].arraySize.empty()) { os << "[" << it->second.members[i].arraySize << "]"; } diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 24e2b60..9b5a048 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -3685,20 +3685,6 @@ namespace VULKAN_HPP_NAMESPACE struct ExtensionProperties { - ExtensionProperties( ) - { - } - - ExtensionProperties( VkExtensionProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( ExtensionProperties ) ); - } - - ExtensionProperties& operator=( VkExtensionProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( ExtensionProperties ) ); - return *this; - } operator const VkExtensionProperties&() const { return *reinterpret_cast(this); @@ -3722,20 +3708,6 @@ namespace VULKAN_HPP_NAMESPACE struct LayerProperties { - LayerProperties( ) - { - } - - LayerProperties( VkLayerProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( LayerProperties ) ); - } - - LayerProperties& operator=( VkLayerProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( LayerProperties ) ); - return *this; - } operator const VkLayerProperties&() const { return *reinterpret_cast(this); @@ -3850,20 +3822,6 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryRequirements { - MemoryRequirements( ) - { - } - - MemoryRequirements( VkMemoryRequirements const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryRequirements ) ); - } - - MemoryRequirements& operator=( VkMemoryRequirements const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryRequirements ) ); - return *this; - } operator const VkMemoryRequirements&() const { return *reinterpret_cast(this); @@ -3949,20 +3907,6 @@ namespace VULKAN_HPP_NAMESPACE struct SubresourceLayout { - SubresourceLayout( ) - { - } - - SubresourceLayout( VkSubresourceLayout const & rhs ) - { - memcpy( this, &rhs, sizeof( SubresourceLayout ) ); - } - - SubresourceLayout& operator=( VkSubresourceLayout const & rhs ) - { - memcpy( this, &rhs, sizeof( SubresourceLayout ) ); - return *this; - } operator const VkSubresourceLayout&() const { return *reinterpret_cast(this); @@ -4843,20 +4787,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceSparseProperties { - PhysicalDeviceSparseProperties( ) - { - } - - PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSparseProperties ) ); - } - - PhysicalDeviceSparseProperties& operator=( VkPhysicalDeviceSparseProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSparseProperties ) ); - return *this; - } operator const VkPhysicalDeviceSparseProperties&() const { return *reinterpret_cast(this); @@ -5093,20 +5023,6 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayPlanePropertiesKHR { - DisplayPlanePropertiesKHR( ) - { - } - - DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPlanePropertiesKHR ) ); - } - - DisplayPlanePropertiesKHR& operator=( VkDisplayPlanePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPlanePropertiesKHR ) ); - return *this; - } operator const VkDisplayPlanePropertiesKHR&() const { return *reinterpret_cast(this); @@ -5181,20 +5097,6 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayModePropertiesKHR { - DisplayModePropertiesKHR( ) - { - } - - DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModePropertiesKHR ) ); - } - - DisplayModePropertiesKHR& operator=( VkDisplayModePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModePropertiesKHR ) ); - return *this; - } operator const VkDisplayModePropertiesKHR&() const { return *reinterpret_cast(this); @@ -5653,20 +5555,6 @@ namespace VULKAN_HPP_NAMESPACE struct ShaderResourceUsageAMD { - ShaderResourceUsageAMD( ) - { - } - - ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderResourceUsageAMD ) ); - } - - ShaderResourceUsageAMD& operator=( VkShaderResourceUsageAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderResourceUsageAMD ) ); - return *this; - } operator const VkShaderResourceUsageAMD&() const { return *reinterpret_cast(this); @@ -7034,9 +6922,7 @@ namespace VULKAN_HPP_NAMESPACE struct ApplicationInfo { ApplicationInfo( const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0 ) - : sType( StructureType::eApplicationInfo ) - , pNext( nullptr ) - , pApplicationName( pApplicationName_ ) + : pApplicationName( pApplicationName_ ) , applicationVersion( applicationVersion_ ) , pEngineName( pEngineName_ ) , engineVersion( engineVersion_ ) @@ -7112,10 +6998,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eApplicationInfo; public: - const void* pNext; + const void* pNext = nullptr; const char* pApplicationName; uint32_t applicationVersion; const char* pEngineName; @@ -7127,9 +7013,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceQueueCreateInfo { DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueCount_ = 0, const float* pQueuePriorities_ = nullptr ) - : sType( StructureType::eDeviceQueueCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , queueFamilyIndex( queueFamilyIndex_ ) , queueCount( queueCount_ ) , pQueuePriorities( pQueuePriorities_ ) @@ -7197,10 +7081,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceQueueCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; DeviceQueueCreateFlags flags; uint32_t queueFamilyIndex; uint32_t queueCount; @@ -7211,9 +7095,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceCreateInfo { DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(), uint32_t queueCreateInfoCount_ = 0, const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr, const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr ) - : sType( StructureType::eDeviceCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , queueCreateInfoCount( queueCreateInfoCount_ ) , pQueueCreateInfos( pQueueCreateInfos_ ) , enabledLayerCount( enabledLayerCount_ ) @@ -7313,10 +7195,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; DeviceCreateFlags flags; uint32_t queueCreateInfoCount; const DeviceQueueCreateInfo* pQueueCreateInfos; @@ -7331,9 +7213,7 @@ namespace VULKAN_HPP_NAMESPACE struct InstanceCreateInfo { InstanceCreateInfo( InstanceCreateFlags flags_ = InstanceCreateFlags(), const ApplicationInfo* pApplicationInfo_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr ) - : sType( StructureType::eInstanceCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , pApplicationInfo( pApplicationInfo_ ) , enabledLayerCount( enabledLayerCount_ ) , ppEnabledLayerNames( ppEnabledLayerNames_ ) @@ -7417,10 +7297,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eInstanceCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; InstanceCreateFlags flags; const ApplicationInfo* pApplicationInfo; uint32_t enabledLayerCount; @@ -7433,9 +7313,7 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryAllocateInfo { MemoryAllocateInfo( DeviceSize allocationSize_ = 0, uint32_t memoryTypeIndex_ = 0 ) - : sType( StructureType::eMemoryAllocateInfo ) - , pNext( nullptr ) - , allocationSize( allocationSize_ ) + : allocationSize( allocationSize_ ) , memoryTypeIndex( memoryTypeIndex_ ) { } @@ -7487,10 +7365,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryAllocateInfo; public: - const void* pNext; + const void* pNext = nullptr; DeviceSize allocationSize; uint32_t memoryTypeIndex; }; @@ -7499,9 +7377,7 @@ namespace VULKAN_HPP_NAMESPACE struct MappedMemoryRange { MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(), DeviceSize offset_ = 0, DeviceSize size_ = 0 ) - : sType( StructureType::eMappedMemoryRange ) - , pNext( nullptr ) - , memory( memory_ ) + : memory( memory_ ) , offset( offset_ ) , size( size_ ) { @@ -7561,10 +7437,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMappedMemoryRange; public: - const void* pNext; + const void* pNext = nullptr; DeviceMemory memory; DeviceSize offset; DeviceSize size; @@ -7574,9 +7450,7 @@ namespace VULKAN_HPP_NAMESPACE struct WriteDescriptorSet { WriteDescriptorSet( DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, const DescriptorImageInfo* pImageInfo_ = nullptr, const DescriptorBufferInfo* pBufferInfo_ = nullptr, const BufferView* pTexelBufferView_ = nullptr ) - : sType( StructureType::eWriteDescriptorSet ) - , pNext( nullptr ) - , dstSet( dstSet_ ) + : dstSet( dstSet_ ) , dstBinding( dstBinding_ ) , dstArrayElement( dstArrayElement_ ) , descriptorCount( descriptorCount_ ) @@ -7676,10 +7550,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eWriteDescriptorSet; public: - const void* pNext; + const void* pNext = nullptr; DescriptorSet dstSet; uint32_t dstBinding; uint32_t dstArrayElement; @@ -7694,9 +7568,7 @@ namespace VULKAN_HPP_NAMESPACE struct CopyDescriptorSet { CopyDescriptorSet( DescriptorSet srcSet_ = DescriptorSet(), uint32_t srcBinding_ = 0, uint32_t srcArrayElement_ = 0, DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0 ) - : sType( StructureType::eCopyDescriptorSet ) - , pNext( nullptr ) - , srcSet( srcSet_ ) + : srcSet( srcSet_ ) , srcBinding( srcBinding_ ) , srcArrayElement( srcArrayElement_ ) , dstSet( dstSet_ ) @@ -7788,10 +7660,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eCopyDescriptorSet; public: - const void* pNext; + const void* pNext = nullptr; DescriptorSet srcSet; uint32_t srcBinding; uint32_t srcArrayElement; @@ -7805,9 +7677,7 @@ namespace VULKAN_HPP_NAMESPACE struct BufferViewCreateInfo { BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(), Buffer buffer_ = Buffer(), Format format_ = Format::eUndefined, DeviceSize offset_ = 0, DeviceSize range_ = 0 ) - : sType( StructureType::eBufferViewCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , buffer( buffer_ ) , format( format_ ) , offset( offset_ ) @@ -7883,10 +7753,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBufferViewCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; BufferViewCreateFlags flags; Buffer buffer; Format format; @@ -7898,9 +7768,7 @@ namespace VULKAN_HPP_NAMESPACE struct ShaderModuleCreateInfo { ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(), size_t codeSize_ = 0, const uint32_t* pCode_ = nullptr ) - : sType( StructureType::eShaderModuleCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , codeSize( codeSize_ ) , pCode( pCode_ ) { @@ -7960,10 +7828,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eShaderModuleCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; ShaderModuleCreateFlags flags; size_t codeSize; const uint32_t* pCode; @@ -7973,9 +7841,7 @@ namespace VULKAN_HPP_NAMESPACE struct DescriptorSetAllocateInfo { DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(), uint32_t descriptorSetCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr ) - : sType( StructureType::eDescriptorSetAllocateInfo ) - , pNext( nullptr ) - , descriptorPool( descriptorPool_ ) + : descriptorPool( descriptorPool_ ) , descriptorSetCount( descriptorSetCount_ ) , pSetLayouts( pSetLayouts_ ) { @@ -8035,10 +7901,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDescriptorSetAllocateInfo; public: - const void* pNext; + const void* pNext = nullptr; DescriptorPool descriptorPool; uint32_t descriptorSetCount; const DescriptorSetLayout* pSetLayouts; @@ -8048,9 +7914,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineVertexInputStateCreateInfo { PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_ = 0, const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, uint32_t vertexAttributeDescriptionCount_ = 0, const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) - : sType( StructureType::ePipelineVertexInputStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ) , pVertexBindingDescriptions( pVertexBindingDescriptions_ ) , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ) @@ -8126,10 +7990,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineVertexInputStateCreateFlags flags; uint32_t vertexBindingDescriptionCount; const VertexInputBindingDescription* pVertexBindingDescriptions; @@ -8141,9 +8005,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineInputAssemblyStateCreateInfo { PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(), PrimitiveTopology topology_ = PrimitiveTopology::ePointList, Bool32 primitiveRestartEnable_ = 0 ) - : sType( StructureType::ePipelineInputAssemblyStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , topology( topology_ ) , primitiveRestartEnable( primitiveRestartEnable_ ) { @@ -8203,10 +8065,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineInputAssemblyStateCreateFlags flags; PrimitiveTopology topology; Bool32 primitiveRestartEnable; @@ -8216,9 +8078,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineTessellationStateCreateInfo { PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_ = 0 ) - : sType( StructureType::ePipelineTessellationStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , patchControlPoints( patchControlPoints_ ) { } @@ -8270,10 +8130,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineTessellationStateCreateFlags flags; uint32_t patchControlPoints; }; @@ -8282,9 +8142,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineViewportStateCreateInfo { PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(), uint32_t viewportCount_ = 0, const Viewport* pViewports_ = nullptr, uint32_t scissorCount_ = 0, const Rect2D* pScissors_ = nullptr ) - : sType( StructureType::ePipelineViewportStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , viewportCount( viewportCount_ ) , pViewports( pViewports_ ) , scissorCount( scissorCount_ ) @@ -8360,10 +8218,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineViewportStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineViewportStateCreateFlags flags; uint32_t viewportCount; const Viewport* pViewports; @@ -8375,9 +8233,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineRasterizationStateCreateInfo { PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = PipelineRasterizationStateCreateFlags(), Bool32 depthClampEnable_ = 0, Bool32 rasterizerDiscardEnable_ = 0, PolygonMode polygonMode_ = PolygonMode::eFill, CullModeFlags cullMode_ = CullModeFlags(), FrontFace frontFace_ = FrontFace::eCounterClockwise, Bool32 depthBiasEnable_ = 0, float depthBiasConstantFactor_ = 0, float depthBiasClamp_ = 0, float depthBiasSlopeFactor_ = 0, float lineWidth_ = 0 ) - : sType( StructureType::ePipelineRasterizationStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , depthClampEnable( depthClampEnable_ ) , rasterizerDiscardEnable( rasterizerDiscardEnable_ ) , polygonMode( polygonMode_ ) @@ -8501,10 +8357,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineRasterizationStateCreateFlags flags; Bool32 depthClampEnable; Bool32 rasterizerDiscardEnable; @@ -8522,9 +8378,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineDepthStencilStateCreateInfo { PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(), Bool32 depthTestEnable_ = 0, Bool32 depthWriteEnable_ = 0, CompareOp depthCompareOp_ = CompareOp::eNever, Bool32 depthBoundsTestEnable_ = 0, Bool32 stencilTestEnable_ = 0, StencilOpState front_ = StencilOpState(), StencilOpState back_ = StencilOpState(), float minDepthBounds_ = 0, float maxDepthBounds_ = 0 ) - : sType( StructureType::ePipelineDepthStencilStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , depthTestEnable( depthTestEnable_ ) , depthWriteEnable( depthWriteEnable_ ) , depthCompareOp( depthCompareOp_ ) @@ -8640,10 +8494,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineDepthStencilStateCreateFlags flags; Bool32 depthTestEnable; Bool32 depthWriteEnable; @@ -8660,9 +8514,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineCacheCreateInfo { PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr ) - : sType( StructureType::ePipelineCacheCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , initialDataSize( initialDataSize_ ) , pInitialData( pInitialData_ ) { @@ -8722,10 +8574,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineCacheCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineCacheCreateFlags flags; size_t initialDataSize; const void* pInitialData; @@ -8735,9 +8587,7 @@ namespace VULKAN_HPP_NAMESPACE struct SamplerCreateInfo { SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), Filter magFilter_ = Filter::eNearest, Filter minFilter_ = Filter::eNearest, SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, float mipLodBias_ = 0, Bool32 anisotropyEnable_ = 0, float maxAnisotropy_ = 0, Bool32 compareEnable_ = 0, CompareOp compareOp_ = CompareOp::eNever, float minLod_ = 0, float maxLod_ = 0, BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, Bool32 unnormalizedCoordinates_ = 0 ) - : sType( StructureType::eSamplerCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , magFilter( magFilter_ ) , minFilter( minFilter_ ) , mipmapMode( mipmapMode_ ) @@ -8901,10 +8751,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSamplerCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; SamplerCreateFlags flags; Filter magFilter; Filter minFilter; @@ -8927,9 +8777,7 @@ namespace VULKAN_HPP_NAMESPACE struct CommandBufferAllocateInfo { CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), CommandBufferLevel level_ = CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = 0 ) - : sType( StructureType::eCommandBufferAllocateInfo ) - , pNext( nullptr ) - , commandPool( commandPool_ ) + : commandPool( commandPool_ ) , level( level_ ) , commandBufferCount( commandBufferCount_ ) { @@ -8989,10 +8837,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eCommandBufferAllocateInfo; public: - const void* pNext; + const void* pNext = nullptr; CommandPool commandPool; CommandBufferLevel level; uint32_t commandBufferCount; @@ -9002,9 +8850,7 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassBeginInfo { RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(), Framebuffer framebuffer_ = Framebuffer(), Rect2D renderArea_ = Rect2D(), uint32_t clearValueCount_ = 0, const ClearValue* pClearValues_ = nullptr ) - : sType( StructureType::eRenderPassBeginInfo ) - , pNext( nullptr ) - , renderPass( renderPass_ ) + : renderPass( renderPass_ ) , framebuffer( framebuffer_ ) , renderArea( renderArea_ ) , clearValueCount( clearValueCount_ ) @@ -9080,10 +8926,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eRenderPassBeginInfo; public: - const void* pNext; + const void* pNext = nullptr; RenderPass renderPass; Framebuffer framebuffer; Rect2D renderArea; @@ -9095,9 +8941,7 @@ namespace VULKAN_HPP_NAMESPACE struct EventCreateInfo { EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() ) - : sType( StructureType::eEventCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) { } @@ -9141,10 +8985,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eEventCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; EventCreateFlags flags; }; static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); @@ -9152,9 +8996,7 @@ namespace VULKAN_HPP_NAMESPACE struct SemaphoreCreateInfo { SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() ) - : sType( StructureType::eSemaphoreCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) { } @@ -9198,10 +9040,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSemaphoreCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; SemaphoreCreateFlags flags; }; static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); @@ -9209,9 +9051,7 @@ namespace VULKAN_HPP_NAMESPACE struct FramebufferCreateInfo { FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(), RenderPass renderPass_ = RenderPass(), uint32_t attachmentCount_ = 0, const ImageView* pAttachments_ = nullptr, uint32_t width_ = 0, uint32_t height_ = 0, uint32_t layers_ = 0 ) - : sType( StructureType::eFramebufferCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , renderPass( renderPass_ ) , attachmentCount( attachmentCount_ ) , pAttachments( pAttachments_ ) @@ -9303,10 +9143,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eFramebufferCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; FramebufferCreateFlags flags; RenderPass renderPass; uint32_t attachmentCount; @@ -9320,9 +9160,7 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayModeCreateInfoKHR { DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(), DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() ) - : sType( StructureType::eDisplayModeCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , parameters( parameters_ ) { } @@ -9374,10 +9212,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDisplayModeCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; DisplayModeCreateFlagsKHR flags; DisplayModeParametersKHR parameters; }; @@ -9386,9 +9224,7 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayPresentInfoKHR { DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(), Rect2D dstRect_ = Rect2D(), Bool32 persistent_ = 0 ) - : sType( StructureType::eDisplayPresentInfoKHR ) - , pNext( nullptr ) - , srcRect( srcRect_ ) + : srcRect( srcRect_ ) , dstRect( dstRect_ ) , persistent( persistent_ ) { @@ -9448,10 +9284,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDisplayPresentInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Rect2D srcRect; Rect2D dstRect; Bool32 persistent; @@ -9462,9 +9298,7 @@ namespace VULKAN_HPP_NAMESPACE struct AndroidSurfaceCreateInfoKHR { AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(), ANativeWindow* window_ = nullptr ) - : sType( StructureType::eAndroidSurfaceCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , window( window_ ) { } @@ -9516,10 +9350,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; AndroidSurfaceCreateFlagsKHR flags; ANativeWindow* window; }; @@ -9530,9 +9364,7 @@ namespace VULKAN_HPP_NAMESPACE struct MirSurfaceCreateInfoKHR { MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), MirConnection* connection_ = nullptr, MirSurface* mirSurface_ = nullptr ) - : sType( StructureType::eMirSurfaceCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , connection( connection_ ) , mirSurface( mirSurface_ ) { @@ -9592,10 +9424,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMirSurfaceCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; MirSurfaceCreateFlagsKHR flags; MirConnection* connection; MirSurface* mirSurface; @@ -9607,9 +9439,7 @@ namespace VULKAN_HPP_NAMESPACE struct ViSurfaceCreateInfoNN { ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(), void* window_ = nullptr ) - : sType( StructureType::eViSurfaceCreateInfoNN ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , window( window_ ) { } @@ -9661,10 +9491,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eViSurfaceCreateInfoNN; public: - const void* pNext; + const void* pNext = nullptr; ViSurfaceCreateFlagsNN flags; void* window; }; @@ -9675,9 +9505,7 @@ namespace VULKAN_HPP_NAMESPACE struct WaylandSurfaceCreateInfoKHR { WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(), struct wl_display* display_ = nullptr, struct wl_surface* surface_ = nullptr ) - : sType( StructureType::eWaylandSurfaceCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , display( display_ ) , surface( surface_ ) { @@ -9737,10 +9565,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; WaylandSurfaceCreateFlagsKHR flags; struct wl_display* display; struct wl_surface* surface; @@ -9752,9 +9580,7 @@ namespace VULKAN_HPP_NAMESPACE struct Win32SurfaceCreateInfoKHR { Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(), HINSTANCE hinstance_ = 0, HWND hwnd_ = 0 ) - : sType( StructureType::eWin32SurfaceCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , hinstance( hinstance_ ) , hwnd( hwnd_ ) { @@ -9814,10 +9640,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Win32SurfaceCreateFlagsKHR flags; HINSTANCE hinstance; HWND hwnd; @@ -9829,9 +9655,7 @@ namespace VULKAN_HPP_NAMESPACE struct XlibSurfaceCreateInfoKHR { XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(), Display* dpy_ = nullptr, Window window_ = 0 ) - : sType( StructureType::eXlibSurfaceCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , dpy( dpy_ ) , window( window_ ) { @@ -9891,10 +9715,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; XlibSurfaceCreateFlagsKHR flags; Display* dpy; Window window; @@ -9906,9 +9730,7 @@ namespace VULKAN_HPP_NAMESPACE struct XcbSurfaceCreateInfoKHR { XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(), xcb_connection_t* connection_ = nullptr, xcb_window_t window_ = 0 ) - : sType( StructureType::eXcbSurfaceCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , connection( connection_ ) , window( window_ ) { @@ -9968,10 +9790,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; XcbSurfaceCreateFlagsKHR flags; xcb_connection_t* connection; xcb_window_t window; @@ -9982,9 +9804,7 @@ namespace VULKAN_HPP_NAMESPACE struct DebugMarkerMarkerInfoEXT { DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, std::array const& color_ = { { 0, 0, 0, 0 } } ) - : sType( StructureType::eDebugMarkerMarkerInfoEXT ) - , pNext( nullptr ) - , pMarkerName( pMarkerName_ ) + : pMarkerName( pMarkerName_ ) { memcpy( &color, color_.data(), 4 * sizeof( float ) ); } @@ -10036,10 +9856,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; const char* pMarkerName; float color[4]; }; @@ -10048,9 +9868,7 @@ namespace VULKAN_HPP_NAMESPACE struct DedicatedAllocationImageCreateInfoNV { DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 ) - : sType( StructureType::eDedicatedAllocationImageCreateInfoNV ) - , pNext( nullptr ) - , dedicatedAllocation( dedicatedAllocation_ ) + : dedicatedAllocation( dedicatedAllocation_ ) { } @@ -10094,10 +9912,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; Bool32 dedicatedAllocation; }; static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" ); @@ -10105,9 +9923,7 @@ namespace VULKAN_HPP_NAMESPACE struct DedicatedAllocationBufferCreateInfoNV { DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 ) - : sType( StructureType::eDedicatedAllocationBufferCreateInfoNV ) - , pNext( nullptr ) - , dedicatedAllocation( dedicatedAllocation_ ) + : dedicatedAllocation( dedicatedAllocation_ ) { } @@ -10151,10 +9967,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; Bool32 dedicatedAllocation; }; static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" ); @@ -10162,9 +9978,7 @@ namespace VULKAN_HPP_NAMESPACE struct DedicatedAllocationMemoryAllocateInfoNV { DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(), Buffer buffer_ = Buffer() ) - : sType( StructureType::eDedicatedAllocationMemoryAllocateInfoNV ) - , pNext( nullptr ) - , image( image_ ) + : image( image_ ) , buffer( buffer_ ) { } @@ -10216,10 +10030,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; Image image; Buffer buffer; }; @@ -10229,9 +10043,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExportMemoryWin32HandleInfoNV { ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 ) - : sType( StructureType::eExportMemoryWin32HandleInfoNV ) - , pNext( nullptr ) - , pAttributes( pAttributes_ ) + : pAttributes( pAttributes_ ) , dwAccess( dwAccess_ ) { } @@ -10283,10 +10095,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; public: - const void* pNext; + const void* pNext = nullptr; const SECURITY_ATTRIBUTES* pAttributes; DWORD dwAccess; }; @@ -10297,9 +10109,7 @@ namespace VULKAN_HPP_NAMESPACE struct Win32KeyedMutexAcquireReleaseInfoNV { Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) - : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoNV ) - , pNext( nullptr ) - , acquireCount( acquireCount_ ) + : acquireCount( acquireCount_ ) , pAcquireSyncs( pAcquireSyncs_ ) , pAcquireKeys( pAcquireKeys_ ) , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ) @@ -10391,10 +10201,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; public: - const void* pNext; + const void* pNext = nullptr; uint32_t acquireCount; const DeviceMemory* pAcquireSyncs; const uint64_t* pAcquireKeys; @@ -10409,9 +10219,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGeneratedCommandsFeaturesNVX { DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 ) - : sType( StructureType::eDeviceGeneratedCommandsFeaturesNVX ) - , pNext( nullptr ) - , computeBindingPointSupport( computeBindingPointSupport_ ) + : computeBindingPointSupport( computeBindingPointSupport_ ) { } @@ -10455,10 +10263,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX; public: - const void* pNext; + const void* pNext = nullptr; Bool32 computeBindingPointSupport; }; static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" ); @@ -10466,9 +10274,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGeneratedCommandsLimitsNVX { DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, uint32_t maxObjectEntryCounts_ = 0, uint32_t minSequenceCountBufferOffsetAlignment_ = 0, uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) - : sType( StructureType::eDeviceGeneratedCommandsLimitsNVX ) - , pNext( nullptr ) - , maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) + : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) , maxObjectEntryCounts( maxObjectEntryCounts_ ) , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ ) , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ ) @@ -10544,10 +10350,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t maxIndirectCommandsLayoutTokenCount; uint32_t maxObjectEntryCounts; uint32_t minSequenceCountBufferOffsetAlignment; @@ -10559,9 +10365,7 @@ namespace VULKAN_HPP_NAMESPACE struct CmdReserveSpaceForCommandsInfoNVX { CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t maxSequencesCount_ = 0 ) - : sType( StructureType::eCmdReserveSpaceForCommandsInfoNVX ) - , pNext( nullptr ) - , objectTable( objectTable_ ) + : objectTable( objectTable_ ) , indirectCommandsLayout( indirectCommandsLayout_ ) , maxSequencesCount( maxSequencesCount_ ) { @@ -10621,10 +10425,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX; public: - const void* pNext; + const void* pNext = nullptr; ObjectTableNVX objectTable; IndirectCommandsLayoutNVX indirectCommandsLayout; uint32_t maxSequencesCount; @@ -10634,9 +10438,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceFeatures2KHR { PhysicalDeviceFeatures2KHR( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() ) - : sType( StructureType::ePhysicalDeviceFeatures2KHR ) - , pNext( nullptr ) - , features( features_ ) + : features( features_ ) { } @@ -10680,10 +10482,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceFeatures2KHR; public: - void* pNext; + void* pNext = nullptr; PhysicalDeviceFeatures features; }; static_assert( sizeof( PhysicalDeviceFeatures2KHR ) == sizeof( VkPhysicalDeviceFeatures2KHR ), "struct and wrapper have different size!" ); @@ -10691,9 +10493,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDevicePushDescriptorPropertiesKHR { PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 ) - : sType( StructureType::ePhysicalDevicePushDescriptorPropertiesKHR ) - , pNext( nullptr ) - , maxPushDescriptors( maxPushDescriptors_ ) + : maxPushDescriptors( maxPushDescriptors_ ) { } @@ -10737,10 +10537,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; public: - void* pNext; + void* pNext = nullptr; uint32_t maxPushDescriptors; }; static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" ); @@ -10748,9 +10548,7 @@ namespace VULKAN_HPP_NAMESPACE struct PresentRegionsKHR { PresentRegionsKHR( uint32_t swapchainCount_ = 0, const PresentRegionKHR* pRegions_ = nullptr ) - : sType( StructureType::ePresentRegionsKHR ) - , pNext( nullptr ) - , swapchainCount( swapchainCount_ ) + : swapchainCount( swapchainCount_ ) , pRegions( pRegions_ ) { } @@ -10802,10 +10600,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePresentRegionsKHR; public: - const void* pNext; + const void* pNext = nullptr; uint32_t swapchainCount; const PresentRegionKHR* pRegions; }; @@ -10814,9 +10612,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceVariablePointerFeaturesKHR { PhysicalDeviceVariablePointerFeaturesKHR( Bool32 variablePointersStorageBuffer_ = 0, Bool32 variablePointers_ = 0 ) - : sType( StructureType::ePhysicalDeviceVariablePointerFeaturesKHR ) - , pNext( nullptr ) - , variablePointersStorageBuffer( variablePointersStorageBuffer_ ) + : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) , variablePointers( variablePointers_ ) { } @@ -10868,10 +10664,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeaturesKHR; public: - void* pNext; + void* pNext = nullptr; Bool32 variablePointersStorageBuffer; Bool32 variablePointers; }; @@ -10879,22 +10675,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceIDPropertiesKHR { - PhysicalDeviceIDPropertiesKHR( ) - : sType( StructureType::ePhysicalDeviceIdPropertiesKHR ) - , pNext( nullptr ) - { - } - - PhysicalDeviceIDPropertiesKHR( VkPhysicalDeviceIDPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceIDPropertiesKHR ) ); - } - - PhysicalDeviceIDPropertiesKHR& operator=( VkPhysicalDeviceIDPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceIDPropertiesKHR ) ); - return *this; - } operator const VkPhysicalDeviceIDPropertiesKHR&() const { return *reinterpret_cast(this); @@ -10917,10 +10697,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceIdPropertiesKHR; public: - void* pNext; + void* pNext = nullptr; uint8_t deviceUUID[VK_UUID_SIZE]; uint8_t driverUUID[VK_UUID_SIZE]; uint8_t deviceLUID[VK_LUID_SIZE_KHR]; @@ -10933,9 +10713,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExportMemoryWin32HandleInfoKHR { ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eExportMemoryWin32HandleInfoKHR ) - , pNext( nullptr ) - , pAttributes( pAttributes_ ) + : pAttributes( pAttributes_ ) , dwAccess( dwAccess_ ) , name( name_ ) { @@ -10995,10 +10773,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; const SECURITY_ATTRIBUTES* pAttributes; DWORD dwAccess; LPCWSTR name; @@ -11009,22 +10787,6 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR struct MemoryWin32HandlePropertiesKHR { - MemoryWin32HandlePropertiesKHR( ) - : sType( StructureType::eMemoryWin32HandlePropertiesKHR ) - , pNext( nullptr ) - { - } - - MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryWin32HandlePropertiesKHR ) ); - } - - MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryWin32HandlePropertiesKHR ) ); - return *this; - } operator const VkMemoryWin32HandlePropertiesKHR&() const { return *reinterpret_cast(this); @@ -11043,10 +10805,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; public: - void* pNext; + void* pNext = nullptr; uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); @@ -11054,22 +10816,6 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryFdPropertiesKHR { - MemoryFdPropertiesKHR( ) - : sType( StructureType::eMemoryFdPropertiesKHR ) - , pNext( nullptr ) - { - } - - MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryFdPropertiesKHR ) ); - } - - MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryFdPropertiesKHR ) ); - return *this; - } operator const VkMemoryFdPropertiesKHR&() const { return *reinterpret_cast(this); @@ -11088,10 +10834,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryFdPropertiesKHR; public: - void* pNext; + void* pNext = nullptr; uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); @@ -11100,9 +10846,7 @@ namespace VULKAN_HPP_NAMESPACE struct Win32KeyedMutexAcquireReleaseInfoKHR { Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) - : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR ) - , pNext( nullptr ) - , acquireCount( acquireCount_ ) + : acquireCount( acquireCount_ ) , pAcquireSyncs( pAcquireSyncs_ ) , pAcquireKeys( pAcquireKeys_ ) , pAcquireTimeouts( pAcquireTimeouts_ ) @@ -11194,10 +10938,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; uint32_t acquireCount; const DeviceMemory* pAcquireSyncs; const uint64_t* pAcquireKeys; @@ -11213,9 +10957,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExportSemaphoreWin32HandleInfoKHR { ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eExportSemaphoreWin32HandleInfoKHR ) - , pNext( nullptr ) - , pAttributes( pAttributes_ ) + : pAttributes( pAttributes_ ) , dwAccess( dwAccess_ ) , name( name_ ) { @@ -11275,10 +11017,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; const SECURITY_ATTRIBUTES* pAttributes; DWORD dwAccess; LPCWSTR name; @@ -11290,9 +11032,7 @@ namespace VULKAN_HPP_NAMESPACE struct D3D12FenceSubmitInfoKHR { D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) - : sType( StructureType::eD3D12FenceSubmitInfoKHR ) - , pNext( nullptr ) - , waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) + : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ) , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) @@ -11360,10 +11100,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; uint32_t waitSemaphoreValuesCount; const uint64_t* pWaitSemaphoreValues; uint32_t signalSemaphoreValuesCount; @@ -11376,9 +11116,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExportFenceWin32HandleInfoKHR { ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eExportFenceWin32HandleInfoKHR ) - , pNext( nullptr ) - , pAttributes( pAttributes_ ) + : pAttributes( pAttributes_ ) , dwAccess( dwAccess_ ) , name( name_ ) { @@ -11438,10 +11176,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; const SECURITY_ATTRIBUTES* pAttributes; DWORD dwAccess; LPCWSTR name; @@ -11452,9 +11190,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMultiviewFeaturesKHX { PhysicalDeviceMultiviewFeaturesKHX( Bool32 multiview_ = 0, Bool32 multiviewGeometryShader_ = 0, Bool32 multiviewTessellationShader_ = 0 ) - : sType( StructureType::ePhysicalDeviceMultiviewFeaturesKHX ) - , pNext( nullptr ) - , multiview( multiview_ ) + : multiview( multiview_ ) , multiviewGeometryShader( multiviewGeometryShader_ ) , multiviewTessellationShader( multiviewTessellationShader_ ) { @@ -11514,10 +11250,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceMultiviewFeaturesKHX; public: - void* pNext; + void* pNext = nullptr; Bool32 multiview; Bool32 multiviewGeometryShader; Bool32 multiviewTessellationShader; @@ -11526,22 +11262,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMultiviewPropertiesKHX { - PhysicalDeviceMultiviewPropertiesKHX( ) - : sType( StructureType::ePhysicalDeviceMultiviewPropertiesKHX ) - , pNext( nullptr ) - { - } - - PhysicalDeviceMultiviewPropertiesKHX( VkPhysicalDeviceMultiviewPropertiesKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewPropertiesKHX ) ); - } - - PhysicalDeviceMultiviewPropertiesKHX& operator=( VkPhysicalDeviceMultiviewPropertiesKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewPropertiesKHX ) ); - return *this; - } operator const VkPhysicalDeviceMultiviewPropertiesKHX&() const { return *reinterpret_cast(this); @@ -11561,10 +11281,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceMultiviewPropertiesKHX; public: - void* pNext; + void* pNext = nullptr; uint32_t maxMultiviewViewCount; uint32_t maxMultiviewInstanceIndex; }; @@ -11573,9 +11293,7 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassMultiviewCreateInfoKHX { RenderPassMultiviewCreateInfoKHX( 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 ) - : sType( StructureType::eRenderPassMultiviewCreateInfoKHX ) - , pNext( nullptr ) - , subpassCount( subpassCount_ ) + : subpassCount( subpassCount_ ) , pViewMasks( pViewMasks_ ) , dependencyCount( dependencyCount_ ) , pViewOffsets( pViewOffsets_ ) @@ -11659,10 +11377,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eRenderPassMultiviewCreateInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t subpassCount; const uint32_t* pViewMasks; uint32_t dependencyCount; @@ -11675,9 +11393,7 @@ namespace VULKAN_HPP_NAMESPACE struct BindBufferMemoryInfoKHR { BindBufferMemoryInfoKHR( Buffer buffer_ = Buffer(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 ) - : sType( StructureType::eBindBufferMemoryInfoKHR ) - , pNext( nullptr ) - , buffer( buffer_ ) + : buffer( buffer_ ) , memory( memory_ ) , memoryOffset( memoryOffset_ ) { @@ -11737,10 +11453,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBindBufferMemoryInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Buffer buffer; DeviceMemory memory; DeviceSize memoryOffset; @@ -11750,9 +11466,7 @@ namespace VULKAN_HPP_NAMESPACE struct BindBufferMemoryDeviceGroupInfoKHX { BindBufferMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr ) - : sType( StructureType::eBindBufferMemoryDeviceGroupInfoKHX ) - , pNext( nullptr ) - , deviceIndexCount( deviceIndexCount_ ) + : deviceIndexCount( deviceIndexCount_ ) , pDeviceIndices( pDeviceIndices_ ) { } @@ -11804,10 +11518,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t deviceIndexCount; const uint32_t* pDeviceIndices; }; @@ -11816,9 +11530,7 @@ namespace VULKAN_HPP_NAMESPACE struct BindImageMemoryInfoKHR { BindImageMemoryInfoKHR( Image image_ = Image(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 ) - : sType( StructureType::eBindImageMemoryInfoKHR ) - , pNext( nullptr ) - , image( image_ ) + : image( image_ ) , memory( memory_ ) , memoryOffset( memoryOffset_ ) { @@ -11878,10 +11590,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBindImageMemoryInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Image image; DeviceMemory memory; DeviceSize memoryOffset; @@ -11891,9 +11603,7 @@ namespace VULKAN_HPP_NAMESPACE struct BindImageMemoryDeviceGroupInfoKHX { BindImageMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr, uint32_t SFRRectCount_ = 0, const Rect2D* pSFRRects_ = nullptr ) - : sType( StructureType::eBindImageMemoryDeviceGroupInfoKHX ) - , pNext( nullptr ) - , deviceIndexCount( deviceIndexCount_ ) + : deviceIndexCount( deviceIndexCount_ ) , pDeviceIndices( pDeviceIndices_ ) , SFRRectCount( SFRRectCount_ ) , pSFRRects( pSFRRects_ ) @@ -11961,10 +11671,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t deviceIndexCount; const uint32_t* pDeviceIndices; uint32_t SFRRectCount; @@ -11975,9 +11685,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGroupRenderPassBeginInfoKHX { DeviceGroupRenderPassBeginInfoKHX( uint32_t deviceMask_ = 0, uint32_t deviceRenderAreaCount_ = 0, const Rect2D* pDeviceRenderAreas_ = nullptr ) - : sType( StructureType::eDeviceGroupRenderPassBeginInfoKHX ) - , pNext( nullptr ) - , deviceMask( deviceMask_ ) + : deviceMask( deviceMask_ ) , deviceRenderAreaCount( deviceRenderAreaCount_ ) , pDeviceRenderAreas( pDeviceRenderAreas_ ) { @@ -12037,10 +11745,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t deviceMask; uint32_t deviceRenderAreaCount; const Rect2D* pDeviceRenderAreas; @@ -12050,9 +11758,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGroupCommandBufferBeginInfoKHX { DeviceGroupCommandBufferBeginInfoKHX( uint32_t deviceMask_ = 0 ) - : sType( StructureType::eDeviceGroupCommandBufferBeginInfoKHX ) - , pNext( nullptr ) - , deviceMask( deviceMask_ ) + : deviceMask( deviceMask_ ) { } @@ -12096,10 +11802,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t deviceMask; }; static_assert( sizeof( DeviceGroupCommandBufferBeginInfoKHX ) == sizeof( VkDeviceGroupCommandBufferBeginInfoKHX ), "struct and wrapper have different size!" ); @@ -12107,9 +11813,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGroupSubmitInfoKHX { DeviceGroupSubmitInfoKHX( 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 ) - : sType( StructureType::eDeviceGroupSubmitInfoKHX ) - , pNext( nullptr ) - , waitSemaphoreCount( waitSemaphoreCount_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ) , commandBufferCount( commandBufferCount_ ) , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ) @@ -12193,10 +11897,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGroupSubmitInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t waitSemaphoreCount; const uint32_t* pWaitSemaphoreDeviceIndices; uint32_t commandBufferCount; @@ -12209,9 +11913,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGroupBindSparseInfoKHX { DeviceGroupBindSparseInfoKHX( uint32_t resourceDeviceIndex_ = 0, uint32_t memoryDeviceIndex_ = 0 ) - : sType( StructureType::eDeviceGroupBindSparseInfoKHX ) - , pNext( nullptr ) - , resourceDeviceIndex( resourceDeviceIndex_ ) + : resourceDeviceIndex( resourceDeviceIndex_ ) , memoryDeviceIndex( memoryDeviceIndex_ ) { } @@ -12263,10 +11965,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGroupBindSparseInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t resourceDeviceIndex; uint32_t memoryDeviceIndex; }; @@ -12275,9 +11977,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImageSwapchainCreateInfoKHX { ImageSwapchainCreateInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR() ) - : sType( StructureType::eImageSwapchainCreateInfoKHX ) - , pNext( nullptr ) - , swapchain( swapchain_ ) + : swapchain( swapchain_ ) { } @@ -12321,10 +12021,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageSwapchainCreateInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; SwapchainKHR swapchain; }; static_assert( sizeof( ImageSwapchainCreateInfoKHX ) == sizeof( VkImageSwapchainCreateInfoKHX ), "struct and wrapper have different size!" ); @@ -12332,9 +12032,7 @@ namespace VULKAN_HPP_NAMESPACE struct BindImageMemorySwapchainInfoKHX { BindImageMemorySwapchainInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint32_t imageIndex_ = 0 ) - : sType( StructureType::eBindImageMemorySwapchainInfoKHX ) - , pNext( nullptr ) - , swapchain( swapchain_ ) + : swapchain( swapchain_ ) , imageIndex( imageIndex_ ) { } @@ -12386,10 +12084,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; SwapchainKHR swapchain; uint32_t imageIndex; }; @@ -12398,9 +12096,7 @@ namespace VULKAN_HPP_NAMESPACE struct AcquireNextImageInfoKHX { AcquireNextImageInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint64_t timeout_ = 0, Semaphore semaphore_ = Semaphore(), Fence fence_ = Fence(), uint32_t deviceMask_ = 0 ) - : sType( StructureType::eAcquireNextImageInfoKHX ) - , pNext( nullptr ) - , swapchain( swapchain_ ) + : swapchain( swapchain_ ) , timeout( timeout_ ) , semaphore( semaphore_ ) , fence( fence_ ) @@ -12476,10 +12172,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eAcquireNextImageInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; SwapchainKHR swapchain; uint64_t timeout; Semaphore semaphore; @@ -12491,9 +12187,7 @@ namespace VULKAN_HPP_NAMESPACE struct HdrMetadataEXT { HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(), XYColorEXT displayPrimaryGreen_ = XYColorEXT(), XYColorEXT displayPrimaryBlue_ = XYColorEXT(), XYColorEXT whitePoint_ = XYColorEXT(), float maxLuminance_ = 0, float minLuminance_ = 0, float maxContentLightLevel_ = 0, float maxFrameAverageLightLevel_ = 0 ) - : sType( StructureType::eHdrMetadataEXT ) - , pNext( nullptr ) - , displayPrimaryRed( displayPrimaryRed_ ) + : displayPrimaryRed( displayPrimaryRed_ ) , displayPrimaryGreen( displayPrimaryGreen_ ) , displayPrimaryBlue( displayPrimaryBlue_ ) , whitePoint( whitePoint_ ) @@ -12593,10 +12287,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eHdrMetadataEXT; public: - const void* pNext; + const void* pNext = nullptr; XYColorEXT displayPrimaryRed; XYColorEXT displayPrimaryGreen; XYColorEXT displayPrimaryBlue; @@ -12611,9 +12305,7 @@ namespace VULKAN_HPP_NAMESPACE struct PresentTimesInfoGOOGLE { PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, const PresentTimeGOOGLE* pTimes_ = nullptr ) - : sType( StructureType::ePresentTimesInfoGOOGLE ) - , pNext( nullptr ) - , swapchainCount( swapchainCount_ ) + : swapchainCount( swapchainCount_ ) , pTimes( pTimes_ ) { } @@ -12665,10 +12357,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePresentTimesInfoGOOGLE; public: - const void* pNext; + const void* pNext = nullptr; uint32_t swapchainCount; const PresentTimeGOOGLE* pTimes; }; @@ -12678,9 +12370,7 @@ namespace VULKAN_HPP_NAMESPACE struct IOSSurfaceCreateInfoMVK { IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr ) - : sType( StructureType::eIosSurfaceCreateInfoMVK ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , pView( pView_ ) { } @@ -12732,10 +12422,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; public: - const void* pNext; + const void* pNext = nullptr; IOSSurfaceCreateFlagsMVK flags; const void* pView; }; @@ -12746,9 +12436,7 @@ namespace VULKAN_HPP_NAMESPACE struct MacOSSurfaceCreateInfoMVK { MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr ) - : sType( StructureType::eMacosSurfaceCreateInfoMVK ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , pView( pView_ ) { } @@ -12800,10 +12488,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; public: - const void* pNext; + const void* pNext = nullptr; MacOSSurfaceCreateFlagsMVK flags; const void* pView; }; @@ -12813,9 +12501,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineViewportWScalingStateCreateInfoNV { PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0, uint32_t viewportCount_ = 0, const ViewportWScalingNV* pViewportWScalings_ = nullptr ) - : sType( StructureType::ePipelineViewportWScalingStateCreateInfoNV ) - , pNext( nullptr ) - , viewportWScalingEnable( viewportWScalingEnable_ ) + : viewportWScalingEnable( viewportWScalingEnable_ ) , viewportCount( viewportCount_ ) , pViewportWScalings( pViewportWScalings_ ) { @@ -12875,10 +12561,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; Bool32 viewportWScalingEnable; uint32_t viewportCount; const ViewportWScalingNV* pViewportWScalings; @@ -12888,9 +12574,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceDiscardRectanglePropertiesEXT { PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 ) - : sType( StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT ) - , pNext( nullptr ) - , maxDiscardRectangles( maxDiscardRectangles_ ) + : maxDiscardRectangles( maxDiscardRectangles_ ) { } @@ -12934,32 +12618,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; public: - void* pNext; + void* pNext = nullptr; uint32_t maxDiscardRectangles; }; static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" ); struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( ) - : sType( StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) - , pNext( nullptr ) - { - } - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) ); - } - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) ); - return *this; - } operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const { return *reinterpret_cast(this); @@ -12978,10 +12646,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; public: - void* pNext; + void* pNext = nullptr; Bool32 perViewPositionAllComponents; }; static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" ); @@ -12989,9 +12657,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceSurfaceInfo2KHR { PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() ) - : sType( StructureType::ePhysicalDeviceSurfaceInfo2KHR ) - , pNext( nullptr ) - , surface( surface_ ) + : surface( surface_ ) { } @@ -13035,10 +12701,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; public: - const void* pNext; + const void* pNext = nullptr; SurfaceKHR surface; }; static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); @@ -13046,9 +12712,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDevice16BitStorageFeaturesKHR { PhysicalDevice16BitStorageFeaturesKHR( Bool32 storageBuffer16BitAccess_ = 0, Bool32 uniformAndStorageBuffer16BitAccess_ = 0, Bool32 storagePushConstant16_ = 0, Bool32 storageInputOutput16_ = 0 ) - : sType( StructureType::ePhysicalDevice16BitStorageFeaturesKHR ) - , pNext( nullptr ) - , storageBuffer16BitAccess( storageBuffer16BitAccess_ ) + : storageBuffer16BitAccess( storageBuffer16BitAccess_ ) , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) , storagePushConstant16( storagePushConstant16_ ) , storageInputOutput16( storageInputOutput16_ ) @@ -13116,10 +12780,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDevice16BitStorageFeaturesKHR; public: - void* pNext; + void* pNext = nullptr; Bool32 storageBuffer16BitAccess; Bool32 uniformAndStorageBuffer16BitAccess; Bool32 storagePushConstant16; @@ -13130,9 +12794,7 @@ namespace VULKAN_HPP_NAMESPACE struct BufferMemoryRequirementsInfo2KHR { BufferMemoryRequirementsInfo2KHR( Buffer buffer_ = Buffer() ) - : sType( StructureType::eBufferMemoryRequirementsInfo2KHR ) - , pNext( nullptr ) - , buffer( buffer_ ) + : buffer( buffer_ ) { } @@ -13176,10 +12838,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBufferMemoryRequirementsInfo2KHR; public: - const void* pNext; + const void* pNext = nullptr; Buffer buffer; }; static_assert( sizeof( BufferMemoryRequirementsInfo2KHR ) == sizeof( VkBufferMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); @@ -13187,9 +12849,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImageMemoryRequirementsInfo2KHR { ImageMemoryRequirementsInfo2KHR( Image image_ = Image() ) - : sType( StructureType::eImageMemoryRequirementsInfo2KHR ) - , pNext( nullptr ) - , image( image_ ) + : image( image_ ) { } @@ -13233,10 +12893,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageMemoryRequirementsInfo2KHR; public: - const void* pNext; + const void* pNext = nullptr; Image image; }; static_assert( sizeof( ImageMemoryRequirementsInfo2KHR ) == sizeof( VkImageMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); @@ -13244,9 +12904,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImageSparseMemoryRequirementsInfo2KHR { ImageSparseMemoryRequirementsInfo2KHR( Image image_ = Image() ) - : sType( StructureType::eImageSparseMemoryRequirementsInfo2KHR ) - , pNext( nullptr ) - , image( image_ ) + : image( image_ ) { } @@ -13290,32 +12948,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2KHR; public: - const void* pNext; + const void* pNext = nullptr; Image image; }; static_assert( sizeof( ImageSparseMemoryRequirementsInfo2KHR ) == sizeof( VkImageSparseMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); struct MemoryRequirements2KHR { - MemoryRequirements2KHR( ) - : sType( StructureType::eMemoryRequirements2KHR ) - , pNext( nullptr ) - { - } - - MemoryRequirements2KHR( VkMemoryRequirements2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryRequirements2KHR ) ); - } - - MemoryRequirements2KHR& operator=( VkMemoryRequirements2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryRequirements2KHR ) ); - return *this; - } operator const VkMemoryRequirements2KHR&() const { return *reinterpret_cast(this); @@ -13334,32 +12976,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryRequirements2KHR; public: - void* pNext; + void* pNext = nullptr; MemoryRequirements memoryRequirements; }; static_assert( sizeof( MemoryRequirements2KHR ) == sizeof( VkMemoryRequirements2KHR ), "struct and wrapper have different size!" ); struct MemoryDedicatedRequirementsKHR { - MemoryDedicatedRequirementsKHR( ) - : sType( StructureType::eMemoryDedicatedRequirementsKHR ) - , pNext( nullptr ) - { - } - - MemoryDedicatedRequirementsKHR( VkMemoryDedicatedRequirementsKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryDedicatedRequirementsKHR ) ); - } - - MemoryDedicatedRequirementsKHR& operator=( VkMemoryDedicatedRequirementsKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryDedicatedRequirementsKHR ) ); - return *this; - } operator const VkMemoryDedicatedRequirementsKHR&() const { return *reinterpret_cast(this); @@ -13379,10 +13005,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryDedicatedRequirementsKHR; public: - void* pNext; + void* pNext = nullptr; Bool32 prefersDedicatedAllocation; Bool32 requiresDedicatedAllocation; }; @@ -13391,9 +13017,7 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryDedicatedAllocateInfoKHR { MemoryDedicatedAllocateInfoKHR( Image image_ = Image(), Buffer buffer_ = Buffer() ) - : sType( StructureType::eMemoryDedicatedAllocateInfoKHR ) - , pNext( nullptr ) - , image( image_ ) + : image( image_ ) , buffer( buffer_ ) { } @@ -13445,10 +13069,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryDedicatedAllocateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Image image; Buffer buffer; }; @@ -13457,9 +13081,7 @@ namespace VULKAN_HPP_NAMESPACE struct SamplerYcbcrConversionInfoKHR { SamplerYcbcrConversionInfoKHR( SamplerYcbcrConversionKHR conversion_ = SamplerYcbcrConversionKHR() ) - : sType( StructureType::eSamplerYcbcrConversionInfoKHR ) - , pNext( nullptr ) - , conversion( conversion_ ) + : conversion( conversion_ ) { } @@ -13503,10 +13125,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSamplerYcbcrConversionInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; SamplerYcbcrConversionKHR conversion; }; static_assert( sizeof( SamplerYcbcrConversionInfoKHR ) == sizeof( VkSamplerYcbcrConversionInfoKHR ), "struct and wrapper have different size!" ); @@ -13514,9 +13136,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR { PhysicalDeviceSamplerYcbcrConversionFeaturesKHR( Bool32 samplerYcbcrConversion_ = 0 ) - : sType( StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) - , pNext( nullptr ) - , samplerYcbcrConversion( samplerYcbcrConversion_ ) + : samplerYcbcrConversion( samplerYcbcrConversion_ ) { } @@ -13560,32 +13180,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR; public: - void* pNext; + void* pNext = nullptr; Bool32 samplerYcbcrConversion; }; static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR ), "struct and wrapper have different size!" ); struct SamplerYcbcrConversionImageFormatPropertiesKHR { - SamplerYcbcrConversionImageFormatPropertiesKHR( ) - : sType( StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR ) - , pNext( nullptr ) - { - } - - SamplerYcbcrConversionImageFormatPropertiesKHR( VkSamplerYcbcrConversionImageFormatPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) ); - } - - SamplerYcbcrConversionImageFormatPropertiesKHR& operator=( VkSamplerYcbcrConversionImageFormatPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) ); - return *this; - } operator const VkSamplerYcbcrConversionImageFormatPropertiesKHR&() const { return *reinterpret_cast(this); @@ -13604,32 +13208,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR; public: - void* pNext; + void* pNext = nullptr; uint32_t combinedImageSamplerDescriptorCount; }; static_assert( sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) == sizeof( VkSamplerYcbcrConversionImageFormatPropertiesKHR ), "struct and wrapper have different size!" ); struct TextureLODGatherFormatPropertiesAMD { - TextureLODGatherFormatPropertiesAMD( ) - : sType( StructureType::eTextureLodGatherFormatPropertiesAMD ) - , pNext( nullptr ) - { - } - - TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( TextureLODGatherFormatPropertiesAMD ) ); - } - - TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( TextureLODGatherFormatPropertiesAMD ) ); - return *this; - } operator const VkTextureLODGatherFormatPropertiesAMD&() const { return *reinterpret_cast(this); @@ -13648,10 +13236,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; public: - void* pNext; + void* pNext = nullptr; Bool32 supportsTextureGatherLODBiasAMD; }; static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); @@ -13659,9 +13247,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineCoverageToColorStateCreateInfoNV { PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 ) - : sType( StructureType::ePipelineCoverageToColorStateCreateInfoNV ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , coverageToColorEnable( coverageToColorEnable_ ) , coverageToColorLocation( coverageToColorLocation_ ) { @@ -13721,10 +13307,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; PipelineCoverageToColorStateCreateFlagsNV flags; Bool32 coverageToColorEnable; uint32_t coverageToColorLocation; @@ -13733,22 +13319,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( ) - : sType( StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) - , pNext( nullptr ) - { - } - - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) ); - } - - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) ); - return *this; - } operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const { return *reinterpret_cast(this); @@ -13768,10 +13338,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT; public: - void* pNext; + void* pNext = nullptr; Bool32 filterMinmaxSingleComponentFormats; Bool32 filterMinmaxImageComponentMapping; }; @@ -13779,22 +13349,6 @@ namespace VULKAN_HPP_NAMESPACE struct MultisamplePropertiesEXT { - MultisamplePropertiesEXT( ) - : sType( StructureType::eMultisamplePropertiesEXT ) - , pNext( nullptr ) - { - } - - MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( MultisamplePropertiesEXT ) ); - } - - MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( MultisamplePropertiesEXT ) ); - return *this; - } operator const VkMultisamplePropertiesEXT&() const { return *reinterpret_cast(this); @@ -13813,10 +13367,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMultisamplePropertiesEXT; public: - void* pNext; + void* pNext = nullptr; Extent2D maxSampleLocationGridSize; }; static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" ); @@ -13824,9 +13378,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 ) - : sType( StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT ) - , pNext( nullptr ) - , advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) + : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) { } @@ -13870,32 +13422,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; public: - void* pNext; + void* pNext = nullptr; Bool32 advancedBlendCoherentOperations; }; static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { - PhysicalDeviceBlendOperationAdvancedPropertiesEXT( ) - : sType( StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT ) - , pNext( nullptr ) - { - } - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) ); - } - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) ); - return *this; - } operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const { return *reinterpret_cast(this); @@ -13919,10 +13455,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; public: - void* pNext; + void* pNext = nullptr; uint32_t advancedBlendMaxColorAttachments; Bool32 advancedBlendIndependentBlend; Bool32 advancedBlendNonPremultipliedSrcColor; @@ -13935,9 +13471,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImageFormatListCreateInfoKHR { ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, const Format* pViewFormats_ = nullptr ) - : sType( StructureType::eImageFormatListCreateInfoKHR ) - , pNext( nullptr ) - , viewFormatCount( viewFormatCount_ ) + : viewFormatCount( viewFormatCount_ ) , pViewFormats( pViewFormats_ ) { } @@ -13989,10 +13523,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageFormatListCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; uint32_t viewFormatCount; const Format* pViewFormats; }; @@ -14001,9 +13535,7 @@ namespace VULKAN_HPP_NAMESPACE struct ValidationCacheCreateInfoEXT { ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr ) - : sType( StructureType::eValidationCacheCreateInfoEXT ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , initialDataSize( initialDataSize_ ) , pInitialData( pInitialData_ ) { @@ -14063,10 +13595,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eValidationCacheCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; ValidationCacheCreateFlagsEXT flags; size_t initialDataSize; const void* pInitialData; @@ -14076,9 +13608,7 @@ namespace VULKAN_HPP_NAMESPACE struct ShaderModuleValidationCacheCreateInfoEXT { ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() ) - : sType( StructureType::eShaderModuleValidationCacheCreateInfoEXT ) - , pNext( nullptr ) - , validationCache( validationCache_ ) + : validationCache( validationCache_ ) { } @@ -14122,10 +13652,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; ValidationCacheEXT validationCache; }; static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); @@ -14133,9 +13663,7 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryHostPointerPropertiesEXT { MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 ) - : sType( StructureType::eMemoryHostPointerPropertiesEXT ) - , pNext( nullptr ) - , memoryTypeBits( memoryTypeBits_ ) + : memoryTypeBits( memoryTypeBits_ ) { } @@ -14179,10 +13707,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; public: - void* pNext; + void* pNext = nullptr; uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" ); @@ -14190,9 +13718,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceExternalMemoryHostPropertiesEXT { PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 ) - : sType( StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT ) - , pNext( nullptr ) - , minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) + : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) { } @@ -14236,10 +13762,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; public: - void* pNext; + void* pNext = nullptr; DeviceSize minImportedHostPointerAlignment; }; static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" ); @@ -14253,9 +13779,7 @@ namespace VULKAN_HPP_NAMESPACE struct PresentInfoKHR { PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t swapchainCount_ = 0, const SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, Result* pResults_ = nullptr ) - : sType( StructureType::ePresentInfoKHR ) - , pNext( nullptr ) - , waitSemaphoreCount( waitSemaphoreCount_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) , pWaitSemaphores( pWaitSemaphores_ ) , swapchainCount( swapchainCount_ ) , pSwapchains( pSwapchains_ ) @@ -14339,10 +13863,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePresentInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; uint32_t waitSemaphoreCount; const Semaphore* pWaitSemaphores; uint32_t swapchainCount; @@ -14371,9 +13895,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineDynamicStateCreateInfo { PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr ) - : sType( StructureType::ePipelineDynamicStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , dynamicStateCount( dynamicStateCount_ ) , pDynamicStates( pDynamicStates_ ) { @@ -14433,10 +13955,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineDynamicStateCreateFlags flags; uint32_t dynamicStateCount; const DynamicState* pDynamicStates; @@ -14452,9 +13974,7 @@ namespace VULKAN_HPP_NAMESPACE struct DescriptorUpdateTemplateCreateInfoKHR { DescriptorUpdateTemplateCreateInfoKHR( DescriptorUpdateTemplateCreateFlagsKHR flags_ = DescriptorUpdateTemplateCreateFlagsKHR(), uint32_t descriptorUpdateEntryCount_ = 0, const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ = nullptr, DescriptorUpdateTemplateTypeKHR templateType_ = DescriptorUpdateTemplateTypeKHR::eDescriptorSet, DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, PipelineLayout pipelineLayout_ = PipelineLayout(), uint32_t set_ = 0 ) - : sType( StructureType::eDescriptorUpdateTemplateCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) , templateType( templateType_ ) @@ -14554,10 +14074,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfoKHR; public: - void* pNext; + void* pNext = nullptr; DescriptorUpdateTemplateCreateFlagsKHR flags; uint32_t descriptorUpdateEntryCount; const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries; @@ -14639,20 +14159,6 @@ namespace VULKAN_HPP_NAMESPACE struct QueueFamilyProperties { - QueueFamilyProperties( ) - { - } - - QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( QueueFamilyProperties ) ); - } - - QueueFamilyProperties& operator=( VkQueueFamilyProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( QueueFamilyProperties ) ); - return *this; - } operator const VkQueueFamilyProperties&() const { return *reinterpret_cast(this); @@ -14680,22 +14186,6 @@ namespace VULKAN_HPP_NAMESPACE struct QueueFamilyProperties2KHR { - QueueFamilyProperties2KHR( ) - : sType( StructureType::eQueueFamilyProperties2KHR ) - , pNext( nullptr ) - { - } - - QueueFamilyProperties2KHR( VkQueueFamilyProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( QueueFamilyProperties2KHR ) ); - } - - QueueFamilyProperties2KHR& operator=( VkQueueFamilyProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( QueueFamilyProperties2KHR ) ); - return *this; - } operator const VkQueueFamilyProperties2KHR&() const { return *reinterpret_cast(this); @@ -14714,10 +14204,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eQueueFamilyProperties2KHR; public: - void* pNext; + void* pNext = nullptr; QueueFamilyProperties queueFamilyProperties; }; static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" ); @@ -14753,20 +14243,6 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryType { - MemoryType( ) - { - } - - MemoryType( VkMemoryType const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryType ) ); - } - - MemoryType& operator=( VkMemoryType const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryType ) ); - return *this; - } operator const VkMemoryType&() const { return *reinterpret_cast(this); @@ -14816,20 +14292,6 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryHeap { - MemoryHeap( ) - { - } - - MemoryHeap( VkMemoryHeap const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryHeap ) ); - } - - MemoryHeap& operator=( VkMemoryHeap const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryHeap ) ); - return *this; - } operator const VkMemoryHeap&() const { return *reinterpret_cast(this); @@ -14853,20 +14315,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMemoryProperties { - PhysicalDeviceMemoryProperties( ) - { - } - - PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryProperties ) ); - } - - PhysicalDeviceMemoryProperties& operator=( VkPhysicalDeviceMemoryProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryProperties ) ); - return *this; - } operator const VkPhysicalDeviceMemoryProperties&() const { return *reinterpret_cast(this); @@ -14894,22 +14342,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMemoryProperties2KHR { - PhysicalDeviceMemoryProperties2KHR( ) - : sType( StructureType::ePhysicalDeviceMemoryProperties2KHR ) - , pNext( nullptr ) - { - } - - PhysicalDeviceMemoryProperties2KHR( VkPhysicalDeviceMemoryProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryProperties2KHR ) ); - } - - PhysicalDeviceMemoryProperties2KHR& operator=( VkPhysicalDeviceMemoryProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryProperties2KHR ) ); - return *this; - } operator const VkPhysicalDeviceMemoryProperties2KHR&() const { return *reinterpret_cast(this); @@ -14928,10 +14360,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2KHR; public: - void* pNext; + void* pNext = nullptr; PhysicalDeviceMemoryProperties memoryProperties; }; static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" ); @@ -14983,9 +14415,7 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryBarrier { MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() ) - : sType( StructureType::eMemoryBarrier ) - , pNext( nullptr ) - , srcAccessMask( srcAccessMask_ ) + : srcAccessMask( srcAccessMask_ ) , dstAccessMask( dstAccessMask_ ) { } @@ -15037,10 +14467,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryBarrier; public: - const void* pNext; + const void* pNext = nullptr; AccessFlags srcAccessMask; AccessFlags dstAccessMask; }; @@ -15049,9 +14479,7 @@ namespace VULKAN_HPP_NAMESPACE struct BufferMemoryBarrier { BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize size_ = 0 ) - : sType( StructureType::eBufferMemoryBarrier ) - , pNext( nullptr ) - , srcAccessMask( srcAccessMask_ ) + : srcAccessMask( srcAccessMask_ ) , dstAccessMask( dstAccessMask_ ) , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) @@ -15143,10 +14571,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBufferMemoryBarrier; public: - const void* pNext; + const void* pNext = nullptr; AccessFlags srcAccessMask; AccessFlags dstAccessMask; uint32_t srcQueueFamilyIndex; @@ -15220,9 +14648,7 @@ namespace VULKAN_HPP_NAMESPACE struct BufferCreateInfo { BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), DeviceSize size_ = 0, BufferUsageFlags usage_ = BufferUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr ) - : sType( StructureType::eBufferCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , size( size_ ) , usage( usage_ ) , sharingMode( sharingMode_ ) @@ -15306,10 +14732,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBufferCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; BufferCreateFlags flags; DeviceSize size; BufferUsageFlags usage; @@ -15432,9 +14858,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineShaderStageCreateInfo { PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr ) - : sType( StructureType::ePipelineShaderStageCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , stage( stage_ ) , module( module_ ) , pName( pName_ ) @@ -15510,10 +14934,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineShaderStageCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineShaderStageCreateFlags flags; ShaderStageFlagBits stage; ShaderModule module; @@ -15585,9 +15009,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineLayoutCreateInfo { PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr ) - : sType( StructureType::ePipelineLayoutCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , setLayoutCount( setLayoutCount_ ) , pSetLayouts( pSetLayouts_ ) , pushConstantRangeCount( pushConstantRangeCount_ ) @@ -15663,10 +15085,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineLayoutCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineLayoutCreateFlags flags; uint32_t setLayoutCount; const DescriptorSetLayout* pSetLayouts; @@ -15677,20 +15099,6 @@ namespace VULKAN_HPP_NAMESPACE struct ShaderStatisticsInfoAMD { - ShaderStatisticsInfoAMD( ) - { - } - - ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderStatisticsInfoAMD ) ); - } - - ShaderStatisticsInfoAMD& operator=( VkShaderStatisticsInfoAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderStatisticsInfoAMD ) ); - return *this; - } operator const VkShaderStatisticsInfoAMD&() const { return *reinterpret_cast(this); @@ -15756,22 +15164,6 @@ namespace VULKAN_HPP_NAMESPACE struct SharedPresentSurfaceCapabilitiesKHR { - SharedPresentSurfaceCapabilitiesKHR( ) - : sType( StructureType::eSharedPresentSurfaceCapabilitiesKHR ) - , pNext( nullptr ) - { - } - - SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SharedPresentSurfaceCapabilitiesKHR ) ); - } - - SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SharedPresentSurfaceCapabilitiesKHR ) ); - return *this; - } operator const VkSharedPresentSurfaceCapabilitiesKHR&() const { return *reinterpret_cast(this); @@ -15790,10 +15182,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; public: - void* pNext; + void* pNext = nullptr; ImageUsageFlags sharedPresentSupportedUsageFlags; }; static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); @@ -15801,9 +15193,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImageViewUsageCreateInfoKHR { ImageViewUsageCreateInfoKHR( ImageUsageFlags usage_ = ImageUsageFlags() ) - : sType( StructureType::eImageViewUsageCreateInfoKHR ) - , pNext( nullptr ) - , usage( usage_ ) + : usage( usage_ ) { } @@ -15847,10 +15237,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageViewUsageCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ImageUsageFlags usage; }; static_assert( sizeof( ImageViewUsageCreateInfoKHR ) == sizeof( VkImageViewUsageCreateInfoKHR ), "struct and wrapper have different size!" ); @@ -15894,9 +15284,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceImageFormatInfo2KHR { PhysicalDeviceImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() ) - : sType( StructureType::ePhysicalDeviceImageFormatInfo2KHR ) - , pNext( nullptr ) - , format( format_ ) + : format( format_ ) , type( type_ ) , tiling( tiling_ ) , usage( usage_ ) @@ -15972,10 +15360,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2KHR; public: - const void* pNext; + const void* pNext = nullptr; Format format; ImageType type; ImageTiling tiling; @@ -16016,9 +15404,7 @@ namespace VULKAN_HPP_NAMESPACE struct ComputePipelineCreateInfo { ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), PipelineLayout layout_ = PipelineLayout(), Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 ) - : sType( StructureType::eComputePipelineCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , stage( stage_ ) , layout( layout_ ) , basePipelineHandle( basePipelineHandle_ ) @@ -16094,10 +15480,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eComputePipelineCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineCreateFlags flags; PipelineShaderStageCreateInfo stage; PipelineLayout layout; @@ -16242,9 +15628,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineColorBlendStateCreateInfo { PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), Bool32 logicOpEnable_ = 0, LogicOp logicOp_ = LogicOp::eClear, uint32_t attachmentCount_ = 0, const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array const& blendConstants_ = { { 0, 0, 0, 0 } } ) - : sType( StructureType::ePipelineColorBlendStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , logicOpEnable( logicOpEnable_ ) , logicOp( logicOp_ ) , attachmentCount( attachmentCount_ ) @@ -16328,10 +15712,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineColorBlendStateCreateFlags flags; Bool32 logicOpEnable; LogicOp logicOp; @@ -16369,9 +15753,7 @@ namespace VULKAN_HPP_NAMESPACE struct FenceCreateInfo { FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() ) - : sType( StructureType::eFenceCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) { } @@ -16415,10 +15797,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eFenceCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; FenceCreateFlags flags; }; static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); @@ -16473,20 +15855,6 @@ namespace VULKAN_HPP_NAMESPACE struct FormatProperties { - FormatProperties( ) - { - } - - FormatProperties( VkFormatProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( FormatProperties ) ); - } - - FormatProperties& operator=( VkFormatProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( FormatProperties ) ); - return *this; - } operator const VkFormatProperties&() const { return *reinterpret_cast(this); @@ -16512,22 +15880,6 @@ namespace VULKAN_HPP_NAMESPACE struct FormatProperties2KHR { - FormatProperties2KHR( ) - : sType( StructureType::eFormatProperties2KHR ) - , pNext( nullptr ) - { - } - - FormatProperties2KHR( VkFormatProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FormatProperties2KHR ) ); - } - - FormatProperties2KHR& operator=( VkFormatProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FormatProperties2KHR ) ); - return *this; - } operator const VkFormatProperties2KHR&() const { return *reinterpret_cast(this); @@ -16546,10 +15898,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eFormatProperties2KHR; public: - void* pNext; + void* pNext = nullptr; FormatProperties formatProperties; }; static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" ); @@ -16672,9 +16024,7 @@ namespace VULKAN_HPP_NAMESPACE struct CommandBufferInheritanceInfo { CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) - : sType( StructureType::eCommandBufferInheritanceInfo ) - , pNext( nullptr ) - , renderPass( renderPass_ ) + : renderPass( renderPass_ ) , subpass( subpass_ ) , framebuffer( framebuffer_ ) , occlusionQueryEnable( occlusionQueryEnable_ ) @@ -16758,10 +16108,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eCommandBufferInheritanceInfo; public: - const void* pNext; + const void* pNext = nullptr; RenderPass renderPass; uint32_t subpass; Framebuffer framebuffer; @@ -16774,9 +16124,7 @@ namespace VULKAN_HPP_NAMESPACE struct CommandBufferBeginInfo { CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) - : sType( StructureType::eCommandBufferBeginInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , pInheritanceInfo( pInheritanceInfo_ ) { } @@ -16828,10 +16176,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eCommandBufferBeginInfo; public: - const void* pNext; + const void* pNext = nullptr; CommandBufferUsageFlags flags; const CommandBufferInheritanceInfo* pInheritanceInfo; }; @@ -16840,9 +16188,7 @@ namespace VULKAN_HPP_NAMESPACE struct QueryPoolCreateInfo { QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) - : sType( StructureType::eQueryPoolCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , queryType( queryType_ ) , queryCount( queryCount_ ) , pipelineStatistics( pipelineStatistics_ ) @@ -16910,10 +16256,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eQueryPoolCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; QueryPoolCreateFlags flags; QueryType queryType; uint32_t queryCount; @@ -17162,9 +16508,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImageMemoryBarrier { ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), ImageLayout oldLayout_ = ImageLayout::eUndefined, ImageLayout newLayout_ = ImageLayout::eUndefined, uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Image image_ = Image(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) - : sType( StructureType::eImageMemoryBarrier ) - , pNext( nullptr ) - , srcAccessMask( srcAccessMask_ ) + : srcAccessMask( srcAccessMask_ ) , dstAccessMask( dstAccessMask_ ) , oldLayout( oldLayout_ ) , newLayout( newLayout_ ) @@ -17264,10 +16608,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageMemoryBarrier; public: - const void* pNext; + const void* pNext = nullptr; AccessFlags srcAccessMask; AccessFlags dstAccessMask; ImageLayout oldLayout; @@ -17282,9 +16626,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImageViewCreateInfo { ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) - : sType( StructureType::eImageViewCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , image( image_ ) , viewType( viewType_ ) , format( format_ ) @@ -17368,10 +16710,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageViewCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; ImageViewCreateFlags flags; Image image; ImageViewType viewType; @@ -17804,9 +17146,7 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassInputAttachmentAspectCreateInfoKHR { RenderPassInputAttachmentAspectCreateInfoKHR( uint32_t aspectReferenceCount_ = 0, const InputAttachmentAspectReferenceKHR* pAspectReferences_ = nullptr ) - : sType( StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR ) - , pNext( nullptr ) - , aspectReferenceCount( aspectReferenceCount_ ) + : aspectReferenceCount( aspectReferenceCount_ ) , pAspectReferences( pAspectReferences_ ) { } @@ -17858,10 +17198,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; uint32_t aspectReferenceCount; const InputAttachmentAspectReferenceKHR* pAspectReferences; }; @@ -17870,9 +17210,7 @@ namespace VULKAN_HPP_NAMESPACE struct BindImagePlaneMemoryInfoKHR { BindImagePlaneMemoryInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor ) - : sType( StructureType::eBindImagePlaneMemoryInfoKHR ) - , pNext( nullptr ) - , planeAspect( planeAspect_ ) + : planeAspect( planeAspect_ ) { } @@ -17916,10 +17254,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBindImagePlaneMemoryInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ImageAspectFlagBits planeAspect; }; static_assert( sizeof( BindImagePlaneMemoryInfoKHR ) == sizeof( VkBindImagePlaneMemoryInfoKHR ), "struct and wrapper have different size!" ); @@ -17927,9 +17265,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImagePlaneMemoryRequirementsInfoKHR { ImagePlaneMemoryRequirementsInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor ) - : sType( StructureType::eImagePlaneMemoryRequirementsInfoKHR ) - , pNext( nullptr ) - , planeAspect( planeAspect_ ) + : planeAspect( planeAspect_ ) { } @@ -17973,10 +17309,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ImageAspectFlagBits planeAspect; }; static_assert( sizeof( ImagePlaneMemoryRequirementsInfoKHR ) == sizeof( VkImagePlaneMemoryRequirementsInfoKHR ), "struct and wrapper have different size!" ); @@ -18010,20 +17346,6 @@ namespace VULKAN_HPP_NAMESPACE struct SparseImageFormatProperties { - SparseImageFormatProperties( ) - { - } - - SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageFormatProperties ) ); - } - - SparseImageFormatProperties& operator=( VkSparseImageFormatProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageFormatProperties ) ); - return *this; - } operator const VkSparseImageFormatProperties&() const { return *reinterpret_cast(this); @@ -18049,20 +17371,6 @@ namespace VULKAN_HPP_NAMESPACE struct SparseImageMemoryRequirements { - SparseImageMemoryRequirements( ) - { - } - - SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryRequirements ) ); - } - - SparseImageMemoryRequirements& operator=( VkSparseImageMemoryRequirements const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryRequirements ) ); - return *this; - } operator const VkSparseImageMemoryRequirements&() const { return *reinterpret_cast(this); @@ -18092,22 +17400,6 @@ namespace VULKAN_HPP_NAMESPACE struct SparseImageFormatProperties2KHR { - SparseImageFormatProperties2KHR( ) - : sType( StructureType::eSparseImageFormatProperties2KHR ) - , pNext( nullptr ) - { - } - - SparseImageFormatProperties2KHR( VkSparseImageFormatProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageFormatProperties2KHR ) ); - } - - SparseImageFormatProperties2KHR& operator=( VkSparseImageFormatProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageFormatProperties2KHR ) ); - return *this; - } operator const VkSparseImageFormatProperties2KHR&() const { return *reinterpret_cast(this); @@ -18126,32 +17418,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSparseImageFormatProperties2KHR; public: - void* pNext; + void* pNext = nullptr; SparseImageFormatProperties properties; }; static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" ); struct SparseImageMemoryRequirements2KHR { - SparseImageMemoryRequirements2KHR( ) - : sType( StructureType::eSparseImageMemoryRequirements2KHR ) - , pNext( nullptr ) - { - } - - SparseImageMemoryRequirements2KHR( VkSparseImageMemoryRequirements2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryRequirements2KHR ) ); - } - - SparseImageMemoryRequirements2KHR& operator=( VkSparseImageMemoryRequirements2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryRequirements2KHR ) ); - return *this; - } operator const VkSparseImageMemoryRequirements2KHR&() const { return *reinterpret_cast(this); @@ -18170,10 +17446,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSparseImageMemoryRequirements2KHR; public: - void* pNext; + void* pNext = nullptr; SparseImageMemoryRequirements memoryRequirements; }; static_assert( sizeof( SparseImageMemoryRequirements2KHR ) == sizeof( VkSparseImageMemoryRequirements2KHR ), "struct and wrapper have different size!" ); @@ -18551,9 +17827,7 @@ namespace VULKAN_HPP_NAMESPACE struct BindSparseInfo { BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t bufferBindCount_ = 0, const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, uint32_t imageOpaqueBindCount_ = 0, const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, uint32_t imageBindCount_ = 0, const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr ) - : sType( StructureType::eBindSparseInfo ) - , pNext( nullptr ) - , waitSemaphoreCount( waitSemaphoreCount_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) , pWaitSemaphores( pWaitSemaphores_ ) , bufferBindCount( bufferBindCount_ ) , pBufferBinds( pBufferBinds_ ) @@ -18669,10 +17943,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eBindSparseInfo; public: - const void* pNext; + const void* pNext = nullptr; uint32_t waitSemaphoreCount; const Semaphore* pWaitSemaphores; uint32_t bufferBindCount; @@ -18757,9 +18031,7 @@ namespace VULKAN_HPP_NAMESPACE struct CommandPoolCreateInfo { CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 ) - : sType( StructureType::eCommandPoolCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , queueFamilyIndex( queueFamilyIndex_ ) { } @@ -18811,10 +18083,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eCommandPoolCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; CommandPoolCreateFlags flags; uint32_t queueFamilyIndex; }; @@ -18903,20 +18175,6 @@ namespace VULKAN_HPP_NAMESPACE struct ImageFormatProperties { - ImageFormatProperties( ) - { - } - - ImageFormatProperties( VkImageFormatProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageFormatProperties ) ); - } - - ImageFormatProperties& operator=( VkImageFormatProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageFormatProperties ) ); - return *this; - } operator const VkImageFormatProperties&() const { return *reinterpret_cast(this); @@ -18947,9 +18205,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImageCreateInfo { ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), ImageType imageType_ = ImageType::e1D, Format format_ = Format::eUndefined, Extent3D extent_ = Extent3D(), uint32_t mipLevels_ = 0, uint32_t arrayLayers_ = 0, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, ImageLayout initialLayout_ = ImageLayout::eUndefined ) - : sType( StructureType::eImageCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , imageType( imageType_ ) , format( format_ ) , extent( extent_ ) @@ -19089,10 +18345,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; ImageCreateFlags flags; ImageType imageType; Format format; @@ -19112,9 +18368,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineMultisampleStateCreateInfo { PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, Bool32 sampleShadingEnable_ = 0, float minSampleShading_ = 0, const SampleMask* pSampleMask_ = nullptr, Bool32 alphaToCoverageEnable_ = 0, Bool32 alphaToOneEnable_ = 0 ) - : sType( StructureType::ePipelineMultisampleStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , rasterizationSamples( rasterizationSamples_ ) , sampleShadingEnable( sampleShadingEnable_ ) , minSampleShading( minSampleShading_ ) @@ -19206,10 +18460,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineMultisampleStateCreateFlags flags; SampleCountFlagBits rasterizationSamples; Bool32 sampleShadingEnable; @@ -19223,9 +18477,7 @@ namespace VULKAN_HPP_NAMESPACE struct GraphicsPipelineCreateInfo { GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), uint32_t stageCount_ = 0, const PipelineShaderStageCreateInfo* pStages_ = nullptr, const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, PipelineLayout layout_ = PipelineLayout(), RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 ) - : sType( StructureType::eGraphicsPipelineCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , stageCount( stageCount_ ) , pStages( pStages_ ) , pVertexInputState( pVertexInputState_ ) @@ -19397,10 +18649,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eGraphicsPipelineCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; PipelineCreateFlags flags; uint32_t stageCount; const PipelineShaderStageCreateInfo* pStages; @@ -19423,20 +18675,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceLimits { - PhysicalDeviceLimits( ) - { - } - - PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceLimits ) ); - } - - PhysicalDeviceLimits& operator=( VkPhysicalDeviceLimits const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceLimits ) ); - return *this; - } operator const VkPhysicalDeviceLimits&() const { return *reinterpret_cast(this); @@ -19668,20 +18906,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceProperties { - PhysicalDeviceProperties( ) - { - } - - PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceProperties ) ); - } - - PhysicalDeviceProperties& operator=( VkPhysicalDeviceProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceProperties ) ); - return *this; - } operator const VkPhysicalDeviceProperties&() const { return *reinterpret_cast(this); @@ -19719,22 +18943,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceProperties2KHR { - PhysicalDeviceProperties2KHR( ) - : sType( StructureType::ePhysicalDeviceProperties2KHR ) - , pNext( nullptr ) - { - } - - PhysicalDeviceProperties2KHR( VkPhysicalDeviceProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceProperties2KHR ) ); - } - - PhysicalDeviceProperties2KHR& operator=( VkPhysicalDeviceProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceProperties2KHR ) ); - return *this; - } operator const VkPhysicalDeviceProperties2KHR&() const { return *reinterpret_cast(this); @@ -19753,32 +18961,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceProperties2KHR; public: - void* pNext; + void* pNext = nullptr; PhysicalDeviceProperties properties; }; static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" ); struct ImageFormatProperties2KHR { - ImageFormatProperties2KHR( ) - : sType( StructureType::eImageFormatProperties2KHR ) - , pNext( nullptr ) - { - } - - ImageFormatProperties2KHR( VkImageFormatProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageFormatProperties2KHR ) ); - } - - ImageFormatProperties2KHR& operator=( VkImageFormatProperties2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageFormatProperties2KHR ) ); - return *this; - } operator const VkImageFormatProperties2KHR&() const { return *reinterpret_cast(this); @@ -19797,10 +18989,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImageFormatProperties2KHR; public: - void* pNext; + void* pNext = nullptr; ImageFormatProperties imageFormatProperties; }; static_assert( sizeof( ImageFormatProperties2KHR ) == sizeof( VkImageFormatProperties2KHR ), "struct and wrapper have different size!" ); @@ -19808,9 +19000,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceSparseImageFormatInfo2KHR { PhysicalDeviceSparseImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageUsageFlags usage_ = ImageUsageFlags(), ImageTiling tiling_ = ImageTiling::eOptimal ) - : sType( StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR ) - , pNext( nullptr ) - , format( format_ ) + : format( format_ ) , type( type_ ) , samples( samples_ ) , usage( usage_ ) @@ -19886,10 +19076,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR; public: - const void* pNext; + const void* pNext = nullptr; Format format; ImageType type; SampleCountFlagBits samples; @@ -19901,9 +19091,7 @@ namespace VULKAN_HPP_NAMESPACE struct SampleLocationsInfoEXT { SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, Extent2D sampleLocationGridSize_ = Extent2D(), uint32_t sampleLocationsCount_ = 0, const SampleLocationEXT* pSampleLocations_ = nullptr ) - : sType( StructureType::eSampleLocationsInfoEXT ) - , pNext( nullptr ) - , sampleLocationsPerPixel( sampleLocationsPerPixel_ ) + : sampleLocationsPerPixel( sampleLocationsPerPixel_ ) , sampleLocationGridSize( sampleLocationGridSize_ ) , sampleLocationsCount( sampleLocationsCount_ ) , pSampleLocations( pSampleLocations_ ) @@ -19971,10 +19159,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSampleLocationsInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; SampleCountFlagBits sampleLocationsPerPixel; Extent2D sampleLocationGridSize; uint32_t sampleLocationsCount; @@ -20087,9 +19275,7 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassSampleLocationsBeginInfoEXT { RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, uint32_t postSubpassSampleLocationsCount_ = 0, const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) - : sType( StructureType::eRenderPassSampleLocationsBeginInfoEXT ) - , pNext( nullptr ) - , attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) + : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ) , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ) , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ ) @@ -20157,10 +19343,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; uint32_t attachmentInitialSampleLocationsCount; const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; uint32_t postSubpassSampleLocationsCount; @@ -20171,9 +19357,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineSampleLocationsStateCreateInfoEXT { PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) - : sType( StructureType::ePipelineSampleLocationsStateCreateInfoEXT ) - , pNext( nullptr ) - , sampleLocationsEnable( sampleLocationsEnable_ ) + : sampleLocationsEnable( sampleLocationsEnable_ ) , sampleLocationsInfo( sampleLocationsInfo_ ) { } @@ -20225,10 +19409,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; Bool32 sampleLocationsEnable; SampleLocationsInfoEXT sampleLocationsInfo; }; @@ -20236,22 +19420,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceSampleLocationsPropertiesEXT { - PhysicalDeviceSampleLocationsPropertiesEXT( ) - : sType( StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT ) - , pNext( nullptr ) - { - } - - PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) ); - } - - PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) ); - return *this; - } operator const VkPhysicalDeviceSampleLocationsPropertiesEXT&() const { return *reinterpret_cast(this); @@ -20274,10 +19442,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; public: - void* pNext; + void* pNext = nullptr; SampleCountFlags sampleLocationSampleCounts; Extent2D maxSampleLocationGridSize; float sampleLocationCoordinateRange[2]; @@ -20480,9 +19648,7 @@ namespace VULKAN_HPP_NAMESPACE struct DescriptorPoolCreateInfo { DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr ) - : sType( StructureType::eDescriptorPoolCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , maxSets( maxSets_ ) , poolSizeCount( poolSizeCount_ ) , pPoolSizes( pPoolSizes_ ) @@ -20550,10 +19716,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDescriptorPoolCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; DescriptorPoolCreateFlags flags; uint32_t maxSets; uint32_t poolSizeCount; @@ -20715,20 +19881,6 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceFormatKHR { - SurfaceFormatKHR( ) - { - } - - SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceFormatKHR ) ); - } - - SurfaceFormatKHR& operator=( VkSurfaceFormatKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceFormatKHR ) ); - return *this; - } operator const VkSurfaceFormatKHR&() const { return *reinterpret_cast(this); @@ -20752,22 +19904,6 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceFormat2KHR { - SurfaceFormat2KHR( ) - : sType( StructureType::eSurfaceFormat2KHR ) - , pNext( nullptr ) - { - } - - SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceFormat2KHR ) ); - } - - SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceFormat2KHR ) ); - return *this; - } operator const VkSurfaceFormat2KHR&() const { return *reinterpret_cast(this); @@ -20786,10 +19922,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSurfaceFormat2KHR; public: - void* pNext; + void* pNext = nullptr; SurfaceFormatKHR surfaceFormat; }; static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); @@ -20824,20 +19960,6 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayPlaneCapabilitiesKHR { - DisplayPlaneCapabilitiesKHR( ) - { - } - - DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPlaneCapabilitiesKHR ) ); - } - - DisplayPlaneCapabilitiesKHR& operator=( VkDisplayPlaneCapabilitiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPlaneCapabilitiesKHR ) ); - return *this; - } operator const VkDisplayPlaneCapabilitiesKHR&() const { return *reinterpret_cast(this); @@ -20936,20 +20058,6 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayPropertiesKHR { - DisplayPropertiesKHR( ) - { - } - - DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPropertiesKHR ) ); - } - - DisplayPropertiesKHR& operator=( VkDisplayPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPropertiesKHR ) ); - return *this; - } operator const VkDisplayPropertiesKHR&() const { return *reinterpret_cast(this); @@ -20984,9 +20092,7 @@ namespace VULKAN_HPP_NAMESPACE struct DisplaySurfaceCreateInfoKHR { DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), DisplayModeKHR displayMode_ = DisplayModeKHR(), uint32_t planeIndex_ = 0, uint32_t planeStackIndex_ = 0, SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, float globalAlpha_ = 0, DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, Extent2D imageExtent_ = Extent2D() ) - : sType( StructureType::eDisplaySurfaceCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , displayMode( displayMode_ ) , planeIndex( planeIndex_ ) , planeStackIndex( planeStackIndex_ ) @@ -21086,10 +20192,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; DisplaySurfaceCreateFlagsKHR flags; DisplayModeKHR displayMode; uint32_t planeIndex; @@ -21103,20 +20209,6 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceCapabilitiesKHR { - SurfaceCapabilitiesKHR( ) - { - } - - SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceCapabilitiesKHR ) ); - } - - SurfaceCapabilitiesKHR& operator=( VkSurfaceCapabilitiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceCapabilitiesKHR ) ); - return *this; - } operator const VkSurfaceCapabilitiesKHR&() const { return *reinterpret_cast(this); @@ -21156,22 +20248,6 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceCapabilities2KHR { - SurfaceCapabilities2KHR( ) - : sType( StructureType::eSurfaceCapabilities2KHR ) - , pNext( nullptr ) - { - } - - SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceCapabilities2KHR ) ); - } - - SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceCapabilities2KHR ) ); - return *this; - } operator const VkSurfaceCapabilities2KHR&() const { return *reinterpret_cast(this); @@ -21190,10 +20266,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSurfaceCapabilities2KHR; public: - void* pNext; + void* pNext = nullptr; SurfaceCapabilitiesKHR surfaceCapabilities; }; static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); @@ -21230,9 +20306,7 @@ namespace VULKAN_HPP_NAMESPACE struct DebugReportCallbackCreateInfoEXT { DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr ) - : sType( StructureType::eDebugReportCallbackCreateInfoEXT ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , pfnCallback( pfnCallback_ ) , pUserData( pUserData_ ) { @@ -21292,10 +20366,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; DebugReportFlagsEXT flags; PFN_vkDebugReportCallbackEXT pfnCallback; void* pUserData; @@ -21345,9 +20419,7 @@ namespace VULKAN_HPP_NAMESPACE struct DebugMarkerObjectNameInfoEXT { DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr ) - : sType( StructureType::eDebugMarkerObjectNameInfoEXT ) - , pNext( nullptr ) - , objectType( objectType_ ) + : objectType( objectType_ ) , object( object_ ) , pObjectName( pObjectName_ ) { @@ -21407,10 +20479,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; DebugReportObjectTypeEXT objectType; uint64_t object; const char* pObjectName; @@ -21420,9 +20492,7 @@ namespace VULKAN_HPP_NAMESPACE struct DebugMarkerObjectTagInfoEXT { DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr ) - : sType( StructureType::eDebugMarkerObjectTagInfoEXT ) - , pNext( nullptr ) - , objectType( objectType_ ) + : objectType( objectType_ ) , object( object_ ) , tagName( tagName_ ) , tagSize( tagSize_ ) @@ -21498,10 +20568,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; DebugReportObjectTypeEXT objectType; uint64_t object; uint64_t tagName; @@ -21519,9 +20589,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineRasterizationStateRasterizationOrderAMD { PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict ) - : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD ) - , pNext( nullptr ) - , rasterizationOrder( rasterizationOrder_ ) + : rasterizationOrder( rasterizationOrder_ ) { } @@ -21565,10 +20633,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; public: - const void* pNext; + const void* pNext = nullptr; RasterizationOrderAMD rasterizationOrder; }; static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); @@ -21604,9 +20672,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalMemoryImageCreateInfoNV { ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) - : sType( StructureType::eExternalMemoryImageCreateInfoNV ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) + : handleTypes( handleTypes_ ) { } @@ -21650,10 +20716,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagsNV handleTypes; }; static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); @@ -21661,9 +20727,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExportMemoryAllocateInfoNV { ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) - : sType( StructureType::eExportMemoryAllocateInfoNV ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) + : handleTypes( handleTypes_ ) { } @@ -21707,10 +20771,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExportMemoryAllocateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagsNV handleTypes; }; static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); @@ -21719,9 +20783,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImportMemoryWin32HandleInfoNV { ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 ) - : sType( StructureType::eImportMemoryWin32HandleInfoNV ) - , pNext( nullptr ) - , handleType( handleType_ ) + : handleType( handleType_ ) , handle( handle_ ) { } @@ -21773,10 +20835,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagsNV handleType; HANDLE handle; }; @@ -21812,20 +20874,6 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalImageFormatPropertiesNV { - ExternalImageFormatPropertiesNV( ) - { - } - - ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalImageFormatPropertiesNV ) ); - } - - ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalImageFormatPropertiesNV ) ); - return *this; - } operator const VkExternalImageFormatPropertiesNV&() const { return *reinterpret_cast(this); @@ -21860,9 +20908,7 @@ namespace VULKAN_HPP_NAMESPACE struct ValidationFlagsEXT { ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) - : sType( StructureType::eValidationFlagsEXT ) - , pNext( nullptr ) - , disabledValidationCheckCount( disabledValidationCheckCount_ ) + : disabledValidationCheckCount( disabledValidationCheckCount_ ) , pDisabledValidationChecks( pDisabledValidationChecks_ ) { } @@ -21914,10 +20960,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eValidationFlagsEXT; public: - const void* pNext; + const void* pNext = nullptr; uint32_t disabledValidationCheckCount; ValidationCheckEXT* pDisabledValidationChecks; }; @@ -22121,9 +21167,7 @@ namespace VULKAN_HPP_NAMESPACE struct IndirectCommandsLayoutCreateInfoNVX { IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) - : sType( StructureType::eIndirectCommandsLayoutCreateInfoNVX ) - , pNext( nullptr ) - , pipelineBindPoint( pipelineBindPoint_ ) + : pipelineBindPoint( pipelineBindPoint_ ) , flags( flags_ ) , tokenCount( tokenCount_ ) , pTokens( pTokens_ ) @@ -22191,10 +21235,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX; public: - const void* pNext; + const void* pNext = nullptr; PipelineBindPoint pipelineBindPoint; IndirectCommandsLayoutUsageFlagsNVX flags; uint32_t tokenCount; @@ -22214,9 +21258,7 @@ namespace VULKAN_HPP_NAMESPACE struct ObjectTableCreateInfoNVX { ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, const uint32_t* pObjectEntryCounts_ = nullptr, const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, uint32_t maxUniformBuffersPerDescriptor_ = 0, uint32_t maxStorageBuffersPerDescriptor_ = 0, uint32_t maxStorageImagesPerDescriptor_ = 0, uint32_t maxSampledImagesPerDescriptor_ = 0, uint32_t maxPipelineLayouts_ = 0 ) - : sType( StructureType::eObjectTableCreateInfoNVX ) - , pNext( nullptr ) - , objectCount( objectCount_ ) + : objectCount( objectCount_ ) , pObjectEntryTypes( pObjectEntryTypes_ ) , pObjectEntryCounts( pObjectEntryCounts_ ) , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) @@ -22324,10 +21366,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eObjectTableCreateInfoNVX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t objectCount; const ObjectEntryTypeNVX* pObjectEntryTypes; const uint32_t* pObjectEntryCounts; @@ -22746,9 +21788,7 @@ namespace VULKAN_HPP_NAMESPACE struct DescriptorSetLayoutCreateInfo { DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr ) - : sType( StructureType::eDescriptorSetLayoutCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , bindingCount( bindingCount_ ) , pBindings( pBindings_ ) { @@ -22808,10 +21848,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; DescriptorSetLayoutCreateFlags flags; uint32_t bindingCount; const DescriptorSetLayoutBinding* pBindings; @@ -22855,9 +21895,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceExternalImageFormatInfoKHR { PhysicalDeviceExternalImageFormatInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalImageFormatInfoKHR ) - , pNext( nullptr ) - , handleType( handleType_ ) + : handleType( handleType_ ) { } @@ -22901,10 +21939,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagBitsKHR handleType; }; static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHR ), "struct and wrapper have different size!" ); @@ -22912,9 +21950,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceExternalBufferInfoKHR { PhysicalDeviceExternalBufferInfoKHR( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalBufferInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , usage( usage_ ) , handleType( handleType_ ) { @@ -22974,10 +22010,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; BufferCreateFlags flags; BufferUsageFlags usage; ExternalMemoryHandleTypeFlagBitsKHR handleType; @@ -22987,9 +22023,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalMemoryImageCreateInfoKHR { ExternalMemoryImageCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) - : sType( StructureType::eExternalMemoryImageCreateInfoKHR ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) + : handleTypes( handleTypes_ ) { } @@ -23033,10 +22067,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExternalMemoryImageCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagsKHR handleTypes; }; static_assert( sizeof( ExternalMemoryImageCreateInfoKHR ) == sizeof( VkExternalMemoryImageCreateInfoKHR ), "struct and wrapper have different size!" ); @@ -23044,9 +22078,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalMemoryBufferCreateInfoKHR { ExternalMemoryBufferCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) - : sType( StructureType::eExternalMemoryBufferCreateInfoKHR ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) + : handleTypes( handleTypes_ ) { } @@ -23090,10 +22122,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExternalMemoryBufferCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagsKHR handleTypes; }; static_assert( sizeof( ExternalMemoryBufferCreateInfoKHR ) == sizeof( VkExternalMemoryBufferCreateInfoKHR ), "struct and wrapper have different size!" ); @@ -23101,9 +22133,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExportMemoryAllocateInfoKHR { ExportMemoryAllocateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) - : sType( StructureType::eExportMemoryAllocateInfoKHR ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) + : handleTypes( handleTypes_ ) { } @@ -23147,10 +22177,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExportMemoryAllocateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagsKHR handleTypes; }; static_assert( sizeof( ExportMemoryAllocateInfoKHR ) == sizeof( VkExportMemoryAllocateInfoKHR ), "struct and wrapper have different size!" ); @@ -23159,9 +22189,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImportMemoryWin32HandleInfoKHR { ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eImportMemoryWin32HandleInfoKHR ) - , pNext( nullptr ) - , handleType( handleType_ ) + : handleType( handleType_ ) , handle( handle_ ) , name( name_ ) { @@ -23221,10 +22249,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagBitsKHR handleType; HANDLE handle; LPCWSTR name; @@ -23236,9 +22264,7 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryGetWin32HandleInfoKHR { MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::eMemoryGetWin32HandleInfoKHR ) - , pNext( nullptr ) - , memory( memory_ ) + : memory( memory_ ) , handleType( handleType_ ) { } @@ -23290,10 +22316,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; DeviceMemory memory; ExternalMemoryHandleTypeFlagBitsKHR handleType; }; @@ -23303,9 +22329,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImportMemoryFdInfoKHR { ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) - : sType( StructureType::eImportMemoryFdInfoKHR ) - , pNext( nullptr ) - , handleType( handleType_ ) + : handleType( handleType_ ) , fd( fd_ ) { } @@ -23357,10 +22381,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImportMemoryFdInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagBitsKHR handleType; int fd; }; @@ -23369,9 +22393,7 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryGetFdInfoKHR { MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::eMemoryGetFdInfoKHR ) - , pNext( nullptr ) - , memory( memory_ ) + : memory( memory_ ) , handleType( handleType_ ) { } @@ -23423,10 +22445,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryGetFdInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; DeviceMemory memory; ExternalMemoryHandleTypeFlagBitsKHR handleType; }; @@ -23435,9 +22457,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImportMemoryHostPointerInfoEXT { ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, void* pHostPointer_ = nullptr ) - : sType( StructureType::eImportMemoryHostPointerInfoEXT ) - , pNext( nullptr ) - , handleType( handleType_ ) + : handleType( handleType_ ) , pHostPointer( pHostPointer_ ) { } @@ -23489,10 +22509,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; ExternalMemoryHandleTypeFlagBitsKHR handleType; void* pHostPointer; }; @@ -23527,20 +22547,6 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalMemoryPropertiesKHR { - ExternalMemoryPropertiesKHR( ) - { - } - - ExternalMemoryPropertiesKHR( VkExternalMemoryPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryPropertiesKHR ) ); - } - - ExternalMemoryPropertiesKHR& operator=( VkExternalMemoryPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryPropertiesKHR ) ); - return *this; - } operator const VkExternalMemoryPropertiesKHR&() const { return *reinterpret_cast(this); @@ -23566,22 +22572,6 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalImageFormatPropertiesKHR { - ExternalImageFormatPropertiesKHR( ) - : sType( StructureType::eExternalImageFormatPropertiesKHR ) - , pNext( nullptr ) - { - } - - ExternalImageFormatPropertiesKHR( VkExternalImageFormatPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalImageFormatPropertiesKHR ) ); - } - - ExternalImageFormatPropertiesKHR& operator=( VkExternalImageFormatPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalImageFormatPropertiesKHR ) ); - return *this; - } operator const VkExternalImageFormatPropertiesKHR&() const { return *reinterpret_cast(this); @@ -23600,32 +22590,16 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExternalImageFormatPropertiesKHR; public: - void* pNext; + void* pNext = nullptr; ExternalMemoryPropertiesKHR externalMemoryProperties; }; static_assert( sizeof( ExternalImageFormatPropertiesKHR ) == sizeof( VkExternalImageFormatPropertiesKHR ), "struct and wrapper have different size!" ); struct ExternalBufferPropertiesKHR { - ExternalBufferPropertiesKHR( ) - : sType( StructureType::eExternalBufferPropertiesKHR ) - , pNext( nullptr ) - { - } - - ExternalBufferPropertiesKHR( VkExternalBufferPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalBufferPropertiesKHR ) ); - } - - ExternalBufferPropertiesKHR& operator=( VkExternalBufferPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalBufferPropertiesKHR ) ); - return *this; - } operator const VkExternalBufferPropertiesKHR&() const { return *reinterpret_cast(this); @@ -23644,10 +22618,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExternalBufferPropertiesKHR; public: - void* pNext; + void* pNext = nullptr; ExternalMemoryPropertiesKHR externalMemoryProperties; }; static_assert( sizeof( ExternalBufferPropertiesKHR ) == sizeof( VkExternalBufferPropertiesKHR ), "struct and wrapper have different size!" ); @@ -23684,9 +22658,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceExternalSemaphoreInfoKHR { PhysicalDeviceExternalSemaphoreInfoKHR( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR ) - , pNext( nullptr ) - , handleType( handleType_ ) + : handleType( handleType_ ) { } @@ -23730,10 +22702,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHR ), "struct and wrapper have different size!" ); @@ -23741,9 +22713,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExportSemaphoreCreateInfoKHR { ExportSemaphoreCreateInfoKHR( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHR() ) - : sType( StructureType::eExportSemaphoreCreateInfoKHR ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) + : handleTypes( handleTypes_ ) { } @@ -23787,10 +22757,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExportSemaphoreCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalSemaphoreHandleTypeFlagsKHR handleTypes; }; static_assert( sizeof( ExportSemaphoreCreateInfoKHR ) == sizeof( VkExportSemaphoreCreateInfoKHR ), "struct and wrapper have different size!" ); @@ -23799,9 +22769,7 @@ namespace VULKAN_HPP_NAMESPACE struct SemaphoreGetWin32HandleInfoKHR { SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::eSemaphoreGetWin32HandleInfoKHR ) - , pNext( nullptr ) - , semaphore( semaphore_ ) + : semaphore( semaphore_ ) , handleType( handleType_ ) { } @@ -23853,10 +22821,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Semaphore semaphore; ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; @@ -23866,9 +22834,7 @@ namespace VULKAN_HPP_NAMESPACE struct SemaphoreGetFdInfoKHR { SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::eSemaphoreGetFdInfoKHR ) - , pNext( nullptr ) - , semaphore( semaphore_ ) + : semaphore( semaphore_ ) , handleType( handleType_ ) { } @@ -23920,10 +22886,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Semaphore semaphore; ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; @@ -23957,22 +22923,6 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalSemaphorePropertiesKHR { - ExternalSemaphorePropertiesKHR( ) - : sType( StructureType::eExternalSemaphorePropertiesKHR ) - , pNext( nullptr ) - { - } - - ExternalSemaphorePropertiesKHR( VkExternalSemaphorePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalSemaphorePropertiesKHR ) ); - } - - ExternalSemaphorePropertiesKHR& operator=( VkExternalSemaphorePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalSemaphorePropertiesKHR ) ); - return *this; - } operator const VkExternalSemaphorePropertiesKHR&() const { return *reinterpret_cast(this); @@ -23993,10 +22943,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExternalSemaphorePropertiesKHR; public: - void* pNext; + void* pNext = nullptr; ExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; ExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; ExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; @@ -24032,9 +22982,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImportSemaphoreWin32HandleInfoKHR { ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eImportSemaphoreWin32HandleInfoKHR ) - , pNext( nullptr ) - , semaphore( semaphore_ ) + : semaphore( semaphore_ ) , flags( flags_ ) , handleType( handleType_ ) , handle( handle_ ) @@ -24110,10 +23058,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Semaphore semaphore; SemaphoreImportFlagsKHR flags; ExternalSemaphoreHandleTypeFlagBitsKHR handleType; @@ -24126,9 +23074,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImportSemaphoreFdInfoKHR { ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) - : sType( StructureType::eImportSemaphoreFdInfoKHR ) - , pNext( nullptr ) - , semaphore( semaphore_ ) + : semaphore( semaphore_ ) , flags( flags_ ) , handleType( handleType_ ) , fd( fd_ ) @@ -24196,10 +23142,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Semaphore semaphore; SemaphoreImportFlagsKHR flags; ExternalSemaphoreHandleTypeFlagBitsKHR handleType; @@ -24238,9 +23184,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceExternalFenceInfoKHR { PhysicalDeviceExternalFenceInfoKHR( ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalFenceInfoKHR ) - , pNext( nullptr ) - , handleType( handleType_ ) + : handleType( handleType_ ) { } @@ -24284,10 +23228,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalFenceHandleTypeFlagBitsKHR handleType; }; static_assert( sizeof( PhysicalDeviceExternalFenceInfoKHR ) == sizeof( VkPhysicalDeviceExternalFenceInfoKHR ), "struct and wrapper have different size!" ); @@ -24295,9 +23239,7 @@ namespace VULKAN_HPP_NAMESPACE struct ExportFenceCreateInfoKHR { ExportFenceCreateInfoKHR( ExternalFenceHandleTypeFlagsKHR handleTypes_ = ExternalFenceHandleTypeFlagsKHR() ) - : sType( StructureType::eExportFenceCreateInfoKHR ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) + : handleTypes( handleTypes_ ) { } @@ -24341,10 +23283,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExportFenceCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; ExternalFenceHandleTypeFlagsKHR handleTypes; }; static_assert( sizeof( ExportFenceCreateInfoKHR ) == sizeof( VkExportFenceCreateInfoKHR ), "struct and wrapper have different size!" ); @@ -24353,9 +23295,7 @@ namespace VULKAN_HPP_NAMESPACE struct FenceGetWin32HandleInfoKHR { FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::eFenceGetWin32HandleInfoKHR ) - , pNext( nullptr ) - , fence( fence_ ) + : fence( fence_ ) , handleType( handleType_ ) { } @@ -24407,10 +23347,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Fence fence; ExternalFenceHandleTypeFlagBitsKHR handleType; }; @@ -24420,9 +23360,7 @@ namespace VULKAN_HPP_NAMESPACE struct FenceGetFdInfoKHR { FenceGetFdInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) - : sType( StructureType::eFenceGetFdInfoKHR ) - , pNext( nullptr ) - , fence( fence_ ) + : fence( fence_ ) , handleType( handleType_ ) { } @@ -24474,10 +23412,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eFenceGetFdInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Fence fence; ExternalFenceHandleTypeFlagBitsKHR handleType; }; @@ -24511,22 +23449,6 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalFencePropertiesKHR { - ExternalFencePropertiesKHR( ) - : sType( StructureType::eExternalFencePropertiesKHR ) - , pNext( nullptr ) - { - } - - ExternalFencePropertiesKHR( VkExternalFencePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalFencePropertiesKHR ) ); - } - - ExternalFencePropertiesKHR& operator=( VkExternalFencePropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalFencePropertiesKHR ) ); - return *this; - } operator const VkExternalFencePropertiesKHR&() const { return *reinterpret_cast(this); @@ -24547,10 +23469,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eExternalFencePropertiesKHR; public: - void* pNext; + void* pNext = nullptr; ExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; ExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; ExternalFenceFeatureFlagsKHR externalFenceFeatures; @@ -24586,9 +23508,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImportFenceWin32HandleInfoKHR { ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eImportFenceWin32HandleInfoKHR ) - , pNext( nullptr ) - , fence( fence_ ) + : fence( fence_ ) , flags( flags_ ) , handleType( handleType_ ) , handle( handle_ ) @@ -24664,10 +23584,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Fence fence; FenceImportFlagsKHR flags; ExternalFenceHandleTypeFlagBitsKHR handleType; @@ -24680,9 +23600,7 @@ namespace VULKAN_HPP_NAMESPACE struct ImportFenceFdInfoKHR { ImportFenceFdInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) - : sType( StructureType::eImportFenceFdInfoKHR ) - , pNext( nullptr ) - , fence( fence_ ) + : fence( fence_ ) , flags( flags_ ) , handleType( handleType_ ) , fd( fd_ ) @@ -24750,10 +23668,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eImportFenceFdInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Fence fence; FenceImportFlagsKHR flags; ExternalFenceHandleTypeFlagBitsKHR handleType; @@ -24788,22 +23706,6 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceCapabilities2EXT { - SurfaceCapabilities2EXT( ) - : sType( StructureType::eSurfaceCapabilities2EXT ) - , pNext( nullptr ) - { - } - - SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceCapabilities2EXT ) ); - } - - SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SurfaceCapabilities2EXT ) ); - return *this; - } operator const VkSurfaceCapabilities2EXT&() const { return *reinterpret_cast(this); @@ -24832,10 +23734,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSurfaceCapabilities2EXT; public: - void* pNext; + void* pNext = nullptr; uint32_t minImageCount; uint32_t maxImageCount; Extent2D currentExtent; @@ -24853,9 +23755,7 @@ namespace VULKAN_HPP_NAMESPACE struct SwapchainCounterCreateInfoEXT { SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() ) - : sType( StructureType::eSwapchainCounterCreateInfoEXT ) - , pNext( nullptr ) - , surfaceCounters( surfaceCounters_ ) + : surfaceCounters( surfaceCounters_ ) { } @@ -24899,10 +23799,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; SurfaceCounterFlagsEXT surfaceCounters; }; static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" ); @@ -24917,9 +23817,7 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayPowerInfoEXT { DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff ) - : sType( StructureType::eDisplayPowerInfoEXT ) - , pNext( nullptr ) - , powerState( powerState_ ) + : powerState( powerState_ ) { } @@ -24963,10 +23861,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDisplayPowerInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; DisplayPowerStateEXT powerState; }; static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); @@ -24979,9 +23877,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceEventInfoEXT { DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug ) - : sType( StructureType::eDeviceEventInfoEXT ) - , pNext( nullptr ) - , deviceEvent( deviceEvent_ ) + : deviceEvent( deviceEvent_ ) { } @@ -25025,10 +23921,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceEventInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; DeviceEventTypeEXT deviceEvent; }; static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); @@ -25041,9 +23937,7 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayEventInfoEXT { DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut ) - : sType( StructureType::eDisplayEventInfoEXT ) - , pNext( nullptr ) - , displayEvent( displayEvent_ ) + : displayEvent( displayEvent_ ) { } @@ -25087,10 +23981,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDisplayEventInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; DisplayEventTypeEXT displayEvent; }; static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); @@ -25151,9 +24045,7 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryAllocateFlagsInfoKHX { MemoryAllocateFlagsInfoKHX( MemoryAllocateFlagsKHX flags_ = MemoryAllocateFlagsKHX(), uint32_t deviceMask_ = 0 ) - : sType( StructureType::eMemoryAllocateFlagsInfoKHX ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , deviceMask( deviceMask_ ) { } @@ -25205,10 +24097,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eMemoryAllocateFlagsInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; MemoryAllocateFlagsKHX flags; uint32_t deviceMask; }; @@ -25244,22 +24136,6 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGroupPresentCapabilitiesKHX { - DeviceGroupPresentCapabilitiesKHX( ) - : sType( StructureType::eDeviceGroupPresentCapabilitiesKHX ) - , pNext( nullptr ) - { - } - - DeviceGroupPresentCapabilitiesKHX( VkDeviceGroupPresentCapabilitiesKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupPresentCapabilitiesKHX ) ); - } - - DeviceGroupPresentCapabilitiesKHX& operator=( VkDeviceGroupPresentCapabilitiesKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupPresentCapabilitiesKHX ) ); - return *this; - } operator const VkDeviceGroupPresentCapabilitiesKHX&() const { return *reinterpret_cast(this); @@ -25279,10 +24155,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX]; DeviceGroupPresentModeFlagsKHX modes; }; @@ -25291,9 +24167,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGroupPresentInfoKHX { DeviceGroupPresentInfoKHX( uint32_t swapchainCount_ = 0, const uint32_t* pDeviceMasks_ = nullptr, DeviceGroupPresentModeFlagBitsKHX mode_ = DeviceGroupPresentModeFlagBitsKHX::eLocal ) - : sType( StructureType::eDeviceGroupPresentInfoKHX ) - , pNext( nullptr ) - , swapchainCount( swapchainCount_ ) + : swapchainCount( swapchainCount_ ) , pDeviceMasks( pDeviceMasks_ ) , mode( mode_ ) { @@ -25353,10 +24227,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGroupPresentInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t swapchainCount; const uint32_t* pDeviceMasks; DeviceGroupPresentModeFlagBitsKHX mode; @@ -25366,9 +24240,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGroupSwapchainCreateInfoKHX { DeviceGroupSwapchainCreateInfoKHX( DeviceGroupPresentModeFlagsKHX modes_ = DeviceGroupPresentModeFlagsKHX() ) - : sType( StructureType::eDeviceGroupSwapchainCreateInfoKHX ) - , pNext( nullptr ) - , modes( modes_ ) + : modes( modes_ ) { } @@ -25412,10 +24284,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; DeviceGroupPresentModeFlagsKHX modes; }; static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHX ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHX ), "struct and wrapper have different size!" ); @@ -25448,9 +24320,7 @@ namespace VULKAN_HPP_NAMESPACE struct SwapchainCreateInfoKHR { SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(), SurfaceKHR surface_ = SurfaceKHR(), uint32_t minImageCount_ = 0, Format imageFormat_ = Format::eUndefined, ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, Extent2D imageExtent_ = Extent2D(), uint32_t imageArrayLayers_ = 0, ImageUsageFlags imageUsage_ = ImageUsageFlags(), SharingMode imageSharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, Bool32 clipped_ = 0, SwapchainKHR oldSwapchain_ = SwapchainKHR() ) - : sType( StructureType::eSwapchainCreateInfoKHR ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , surface( surface_ ) , minImageCount( minImageCount_ ) , imageFormat( imageFormat_ ) @@ -25614,10 +24484,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSwapchainCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; SwapchainCreateFlagsKHR flags; SurfaceKHR surface; uint32_t minImageCount; @@ -25721,9 +24591,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineViewportSwizzleStateCreateInfoNV { PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_ = 0, const ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) - : sType( StructureType::ePipelineViewportSwizzleStateCreateInfoNV ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , viewportCount( viewportCount_ ) , pViewportSwizzles( pViewportSwizzles_ ) { @@ -25783,10 +24651,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; PipelineViewportSwizzleStateCreateFlagsNV flags; uint32_t viewportCount; const ViewportSwizzleNV* pViewportSwizzles; @@ -25802,9 +24670,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineDiscardRectangleStateCreateInfoEXT { PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = 0, const Rect2D* pDiscardRectangles_ = nullptr ) - : sType( StructureType::ePipelineDiscardRectangleStateCreateInfoEXT ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , discardRectangleMode( discardRectangleMode_ ) , discardRectangleCount( discardRectangleCount_ ) , pDiscardRectangles( pDiscardRectangles_ ) @@ -25872,10 +24738,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; PipelineDiscardRectangleStateCreateFlagsEXT flags; DiscardRectangleModeEXT discardRectangleMode; uint32_t discardRectangleCount; @@ -26035,9 +24901,7 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassCreateInfo { RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, const AttachmentDescription* pAttachments_ = nullptr, uint32_t subpassCount_ = 0, const SubpassDescription* pSubpasses_ = nullptr, uint32_t dependencyCount_ = 0, const SubpassDependency* pDependencies_ = nullptr ) - : sType( StructureType::eRenderPassCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , attachmentCount( attachmentCount_ ) , pAttachments( pAttachments_ ) , subpassCount( subpassCount_ ) @@ -26129,10 +24993,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eRenderPassCreateInfo; public: - const void* pNext; + const void* pNext = nullptr; RenderPassCreateFlags flags; uint32_t attachmentCount; const AttachmentDescription* pAttachments; @@ -26151,22 +25015,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDevicePointClippingPropertiesKHR { - PhysicalDevicePointClippingPropertiesKHR( ) - : sType( StructureType::ePhysicalDevicePointClippingPropertiesKHR ) - , pNext( nullptr ) - { - } - - PhysicalDevicePointClippingPropertiesKHR( VkPhysicalDevicePointClippingPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevicePointClippingPropertiesKHR ) ); - } - - PhysicalDevicePointClippingPropertiesKHR& operator=( VkPhysicalDevicePointClippingPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevicePointClippingPropertiesKHR ) ); - return *this; - } operator const VkPhysicalDevicePointClippingPropertiesKHR&() const { return *reinterpret_cast(this); @@ -26185,10 +25033,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDevicePointClippingPropertiesKHR; public: - void* pNext; + void* pNext = nullptr; PointClippingBehaviorKHR pointClippingBehavior; }; static_assert( sizeof( PhysicalDevicePointClippingPropertiesKHR ) == sizeof( VkPhysicalDevicePointClippingPropertiesKHR ), "struct and wrapper have different size!" ); @@ -26203,9 +25051,7 @@ namespace VULKAN_HPP_NAMESPACE struct SamplerReductionModeCreateInfoEXT { SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage ) - : sType( StructureType::eSamplerReductionModeCreateInfoEXT ) - , pNext( nullptr ) - , reductionMode( reductionMode_ ) + : reductionMode( reductionMode_ ) { } @@ -26249,10 +25095,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; SamplerReductionModeEXT reductionMode; }; static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" ); @@ -26266,9 +25112,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineTessellationDomainOriginStateCreateInfoKHR { PipelineTessellationDomainOriginStateCreateInfoKHR( TessellationDomainOriginKHR domainOrigin_ = TessellationDomainOriginKHR::eUpperLeft ) - : sType( StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR ) - , pNext( nullptr ) - , domainOrigin( domainOrigin_ ) + : domainOrigin( domainOrigin_ ) { } @@ -26312,10 +25156,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; TessellationDomainOriginKHR domainOrigin; }; static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfoKHR ), "struct and wrapper have different size!" ); @@ -26344,9 +25188,7 @@ namespace VULKAN_HPP_NAMESPACE struct SamplerYcbcrConversionCreateInfoKHR { SamplerYcbcrConversionCreateInfoKHR( Format format_ = Format::eUndefined, SamplerYcbcrModelConversionKHR ycbcrModel_ = SamplerYcbcrModelConversionKHR::eRgbIdentity, SamplerYcbcrRangeKHR ycbcrRange_ = SamplerYcbcrRangeKHR::eItuFull, ComponentMapping components_ = ComponentMapping(), ChromaLocationKHR xChromaOffset_ = ChromaLocationKHR::eCositedEven, ChromaLocationKHR yChromaOffset_ = ChromaLocationKHR::eCositedEven, Filter chromaFilter_ = Filter::eNearest, Bool32 forceExplicitReconstruction_ = 0 ) - : sType( StructureType::eSamplerYcbcrConversionCreateInfoKHR ) - , pNext( nullptr ) - , format( format_ ) + : format( format_ ) , ycbcrModel( ycbcrModel_ ) , ycbcrRange( ycbcrRange_ ) , components( components_ ) @@ -26446,10 +25288,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfoKHR; public: - const void* pNext; + const void* pNext = nullptr; Format format; SamplerYcbcrModelConversionKHR ycbcrModel; SamplerYcbcrRangeKHR ycbcrRange; @@ -26471,9 +25313,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineColorBlendAdvancedStateCreateInfoEXT { PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0, Bool32 dstPremultiplied_ = 0, BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated ) - : sType( StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT ) - , pNext( nullptr ) - , srcPremultiplied( srcPremultiplied_ ) + : srcPremultiplied( srcPremultiplied_ ) , dstPremultiplied( dstPremultiplied_ ) , blendOverlap( blendOverlap_ ) { @@ -26533,10 +25373,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; Bool32 srcPremultiplied; Bool32 dstPremultiplied; BlendOverlapEXT blendOverlap; @@ -26554,9 +25394,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineCoverageModulationStateCreateInfoNV { PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(), CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, Bool32 coverageModulationTableEnable_ = 0, uint32_t coverageModulationTableCount_ = 0, const float* pCoverageModulationTable_ = nullptr ) - : sType( StructureType::ePipelineCoverageModulationStateCreateInfoNV ) - , pNext( nullptr ) - , flags( flags_ ) + : flags( flags_ ) , coverageModulationMode( coverageModulationMode_ ) , coverageModulationTableEnable( coverageModulationTableEnable_ ) , coverageModulationTableCount( coverageModulationTableCount_ ) @@ -26632,10 +25470,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; public: - const void* pNext; + const void* pNext = nullptr; PipelineCoverageModulationStateCreateFlagsNV flags; CoverageModulationModeNV coverageModulationMode; Bool32 coverageModulationTableEnable; @@ -26667,9 +25505,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceQueueGlobalPriorityCreateInfoEXT { DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow ) - : sType( StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT ) - , pNext( nullptr ) - , globalPriority( globalPriority_ ) + : globalPriority( globalPriority_ ) { } @@ -26713,10 +25549,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; public: - const void* pNext; + const void* pNext = nullptr; QueueGlobalPriorityEXT globalPriority; }; static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" ); @@ -27576,9 +26412,7 @@ namespace VULKAN_HPP_NAMESPACE struct SubmitInfo { SubmitInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, const PipelineStageFlags* pWaitDstStageMask_ = nullptr, uint32_t commandBufferCount_ = 0, const CommandBuffer* pCommandBuffers_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr ) - : sType( StructureType::eSubmitInfo ) - , pNext( nullptr ) - , waitSemaphoreCount( waitSemaphoreCount_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) , pWaitSemaphores( pWaitSemaphores_ ) , pWaitDstStageMask( pWaitDstStageMask_ ) , commandBufferCount( commandBufferCount_ ) @@ -27670,10 +26504,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eSubmitInfo; public: - const void* pNext; + const void* pNext = nullptr; uint32_t waitSemaphoreCount; const Semaphore* pWaitSemaphores; const PipelineStageFlags* pWaitDstStageMask; @@ -32385,9 +31219,7 @@ namespace VULKAN_HPP_NAMESPACE struct CmdProcessCommandsInfoNVX { CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t indirectCommandsTokenCount_ = 0, const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, uint32_t maxSequencesCount_ = 0, CommandBuffer targetCommandBuffer_ = CommandBuffer(), Buffer sequencesCountBuffer_ = Buffer(), DeviceSize sequencesCountOffset_ = 0, Buffer sequencesIndexBuffer_ = Buffer(), DeviceSize sequencesIndexOffset_ = 0 ) - : sType( StructureType::eCmdProcessCommandsInfoNVX ) - , pNext( nullptr ) - , objectTable( objectTable_ ) + : objectTable( objectTable_ ) , indirectCommandsLayout( indirectCommandsLayout_ ) , indirectCommandsTokenCount( indirectCommandsTokenCount_ ) , pIndirectCommandsTokens( pIndirectCommandsTokens_ ) @@ -32503,10 +31335,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eCmdProcessCommandsInfoNVX; public: - const void* pNext; + const void* pNext = nullptr; ObjectTableNVX objectTable; IndirectCommandsLayoutNVX indirectCommandsLayout; uint32_t indirectCommandsTokenCount; @@ -32522,22 +31354,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceGroupPropertiesKHX { - PhysicalDeviceGroupPropertiesKHX( ) - : sType( StructureType::ePhysicalDeviceGroupPropertiesKHX ) - , pNext( nullptr ) - { - } - - PhysicalDeviceGroupPropertiesKHX( VkPhysicalDeviceGroupPropertiesKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceGroupPropertiesKHX ) ); - } - - PhysicalDeviceGroupPropertiesKHX& operator=( VkPhysicalDeviceGroupPropertiesKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceGroupPropertiesKHX ) ); - return *this; - } operator const VkPhysicalDeviceGroupPropertiesKHX&() const { return *reinterpret_cast(this); @@ -32558,10 +31374,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::ePhysicalDeviceGroupPropertiesKHX; public: - void* pNext; + void* pNext = nullptr; uint32_t physicalDeviceCount; PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX]; Bool32 subsetAllocation; @@ -33189,9 +32005,7 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceGroupDeviceCreateInfoKHX { DeviceGroupDeviceCreateInfoKHX( uint32_t physicalDeviceCount_ = 0, const PhysicalDevice* pPhysicalDevices_ = nullptr ) - : sType( StructureType::eDeviceGroupDeviceCreateInfoKHX ) - , pNext( nullptr ) - , physicalDeviceCount( physicalDeviceCount_ ) + : physicalDeviceCount( physicalDeviceCount_ ) , pPhysicalDevices( pPhysicalDevices_ ) { } @@ -33243,10 +32057,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - StructureType sType; + StructureType sType = StructureType::eDeviceGroupDeviceCreateInfoKHX; public: - const void* pNext; + const void* pNext = nullptr; uint32_t physicalDeviceCount; const PhysicalDevice* pPhysicalDevices; };