diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 14b0a01..7b24032 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -114,13 +114,12 @@ namespace VULKAN_HPP_NAMESPACE {}; ${enums} ${indexTypeTraits} -${bitmasks}} // namespace VULKAN_HPP_NAMESPACE +} // namespace VULKAN_HPP_NAMESPACE #endif )"; std::string str = replaceWithMap( vulkanEnumsHppTemplate, - { { "bitmasks", generateBitmasks() }, - { "enums", generateEnums() }, + { { "enums", generateEnums() }, { "indexTypeTraits", generateIndexTypeTraits() }, { "licenseHeader", m_vulkanLicenseHeader } } ); @@ -574,7 +573,8 @@ void VulkanHppGenerator::addMissingFlagBits( std::vector & requireD // some flagsBits are specified but never listed as required for any flags! // so, even if this bitmask has no enum listed as required, it might still already exist in the enums list - if ( m_enums.find( flagBits ) == m_enums.end() ) + auto enumIt = m_enums.find( flagBits ); + if ( enumIt == m_enums.end() ) { m_enums.insert( std::make_pair( flagBits, EnumData( 0, true ) ) ); @@ -584,6 +584,7 @@ void VulkanHppGenerator::addMissingFlagBits( std::vector & requireD else { assert( m_types.find( flagBits ) != m_types.end() ); + enumIt->second.isBitmask = true; } newTypes.push_back( flagBits ); @@ -2098,7 +2099,7 @@ std::string VulkanHppGenerator::generateBitmask( std::mapsecond.values.empty() ) { - allFlags = "0"; + allFlags = " {};"; } else { @@ -2116,79 +2117,31 @@ std::string VulkanHppGenerator::generateBitmask( std::mapfirst, value.name, true, m_tags ); - allFlags += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + " " + ( encounteredFlag ? "| " : " " ) + - bitmaskIt->second.type + "( " + enumName + "::" + valueName + " )"; + allFlags += + ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + " " + ( encounteredFlag ? "| " : " " ) + enumName + "::" + valueName; encounteredFlag = true; previousEnter = enter; previousLeave = leave; } if ( !previousLeave.empty() ) { - assert( previousLeave.ends_with( "\n" ) ); - previousLeave.resize( previousLeave.size() - strlen( "\n" ) ); allFlags += "\n" + previousLeave; } + allFlags += ";"; } static const std::string bitmaskTemplate = R"( + using ${bitmaskName} = Flags<${enumName}>; +${alias} + template <> struct FlagTraits<${enumName}> { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : ${bitmaskType} - { - allFlags = ${allFlags} - }; + static VULKAN_HPP_CONST_OR_CONSTEXPR ${bitmaskName} allFlags = ${allFlags} }; - using ${bitmaskName} = Flags<${enumName}>; -${alias})"; +)"; - return replaceWithMap( - bitmaskTemplate, - { { "alias", alias }, { "allFlags", allFlags }, { "bitmaskName", bitmaskName }, { "bitmaskType", bitmaskIt->second.type }, { "enumName", enumName } } ); -} - -std::string VulkanHppGenerator::generateBitmasks() const -{ - const std::string bitmasksTemplate = R"( - //================ - //=== BITMASKs === - //================ - -${bitmasks})"; - - std::string bitmasks; - std::set listedBitmasks; - for ( auto const & feature : m_features ) - { - bitmasks += generateBitmasks( feature.second.requireData, listedBitmasks, feature.first ); - } - for ( auto const & extIt : m_extensionsByNumber ) - { - bitmasks += generateBitmasks( extIt.second->second.requireData, listedBitmasks, extIt.second->first ); - } - - return replaceWithMap( bitmasksTemplate, { { "bitmasks", bitmasks } } ); -} - -std::string - VulkanHppGenerator::generateBitmasks( std::vector const & requireData, std::set & listedBitmasks, std::string const & title ) const -{ - std::string surroundingProtect = getProtectFromTitle( title ); - std::string str; - for ( auto const & require : requireData ) - { - for ( auto const & type : require.types ) - { - auto bitmaskIt = m_bitmasks.find( type ); - if ( ( bitmaskIt != m_bitmasks.end() ) && ( listedBitmasks.find( type ) == listedBitmasks.end() ) ) - { - listedBitmasks.insert( type ); - str += generateBitmask( bitmaskIt, surroundingProtect ); - } - } - } - return addTitleAndProtection( title, str ); + return replaceWithMap( bitmaskTemplate, { { "alias", alias }, { "allFlags", allFlags }, { "bitmaskName", bitmaskName }, { "enumName", enumName } } ); } std::string VulkanHppGenerator::generateBitmasksToString() const @@ -4911,13 +4864,14 @@ std::string VulkanHppGenerator::generateDispatchLoaderStaticCommands( std::vecto std::string VulkanHppGenerator::generateEnum( std::pair const & enumData, std::string const & surroundingProtect ) const { - std::string bitmask; + std::string baseType, bitmask; if ( enumData.second.isBitmask ) { auto bitmaskIt = std::find_if( m_bitmasks.begin(), m_bitmasks.end(), [&enumData]( auto const & bitmask ) { return bitmask.second.requirements == enumData.first; } ); assert( bitmaskIt != m_bitmasks.end() ); - bitmask = " : " + bitmaskIt->first; + baseType = " : " + bitmaskIt->first; + bitmask = generateBitmask( bitmaskIt, surroundingProtect ); } std::string enumValues, previousEnter, previousLeave; @@ -5009,12 +4963,16 @@ std::string VulkanHppGenerator::generateEnum( std::pair c enumUsing += " using " + stripPrefix( enumData.second.alias, "Vk" ) + " = " + stripPrefix( enumData.first, "Vk" ) + ";\n"; } - const std::string enumTemplate = R"( enum class ${enumName}${bitmask} + const std::string enumTemplate = R"( enum class ${enumName}${baseType} {${enumValues}}; -${enumUsing})"; +${enumUsing}${bitmask})"; - return replaceWithMap( - enumTemplate, { { "bitmask", bitmask }, { "enumName", stripPrefix( enumData.first, "Vk" ) }, { "enumUsing", enumUsing }, { "enumValues", enumValues } } ); + return replaceWithMap( enumTemplate, + { { "baseType", baseType }, + { "bitmask", bitmask }, + { "enumName", stripPrefix( enumData.first, "Vk" ) }, + { "enumUsing", enumUsing }, + { "enumValues", enumValues } } ); } std::string VulkanHppGenerator::generateEnums() const @@ -5932,6 +5890,10 @@ std::string VulkanHppGenerator::generateHandles() const std::string VulkanHppGenerator::generateIndexTypeTraits() const { const std::string indexTypeTraitsTemplate = R"( + //========================= + //=== Index Type Traits === + //========================= + template struct IndexTypeValue {}; diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index aba46b4..bac5385 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -456,8 +456,6 @@ private: bool raii ) const; std::string generateBaseTypes() const; std::string generateBitmask( std::map::const_iterator bitmaskIt, std::string const & surroundingProtect ) const; - std::string generateBitmasks() const; - std::string generateBitmasks( std::vector const & requireData, std::set & listedBitmasks, std::string const & title ) const; std::string generateBitmasksToString() const; std::string generateBitmasksToString( std::vector const & requireData, std::set & listedBitmasks, std::string const & title ) const; std::string generateBitmaskToString( std::map::const_iterator bitmaskIt ) const; diff --git a/vulkan/vulkan_enums.hpp b/vulkan/vulkan_enums.hpp index 8801c65..9d5f327 100644 --- a/vulkan/vulkan_enums.hpp +++ b/vulkan/vulkan_enums.hpp @@ -1460,6 +1460,34 @@ namespace VULKAN_HPP_NAMESPACE eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR }; + using FormatFeatureFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags allFlags = + FormatFeatureFlagBits::eSampledImage | FormatFeatureFlagBits::eStorageImage | FormatFeatureFlagBits::eStorageImageAtomic | + FormatFeatureFlagBits::eUniformTexelBuffer | FormatFeatureFlagBits::eStorageTexelBuffer | FormatFeatureFlagBits::eStorageTexelBufferAtomic | + FormatFeatureFlagBits::eVertexBuffer | FormatFeatureFlagBits::eColorAttachment | FormatFeatureFlagBits::eColorAttachmentBlend | + FormatFeatureFlagBits::eDepthStencilAttachment | FormatFeatureFlagBits::eBlitSrc | FormatFeatureFlagBits::eBlitDst | + FormatFeatureFlagBits::eSampledImageFilterLinear | FormatFeatureFlagBits::eTransferSrc | FormatFeatureFlagBits::eTransferDst | + FormatFeatureFlagBits::eMidpointChromaSamples | FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter | + FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter | + FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit | + FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable | FormatFeatureFlagBits::eDisjoint | + FormatFeatureFlagBits::eCositedChromaSamples | FormatFeatureFlagBits::eSampledImageFilterMinmax +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | FormatFeatureFlagBits::eVideoDecodeOutputKHR | FormatFeatureFlagBits::eVideoDecodeDpbKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR | FormatFeatureFlagBits::eSampledImageFilterCubicEXT | + FormatFeatureFlagBits::eFragmentDensityMapEXT | FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | FormatFeatureFlagBits::eVideoEncodeInputKHR | FormatFeatureFlagBits::eVideoEncodeDpbKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ; + }; + enum class ImageCreateFlagBits : VkImageCreateFlags { eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, @@ -1488,6 +1516,22 @@ namespace VULKAN_HPP_NAMESPACE eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR }; + using ImageCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCreateFlags allFlags = + ImageCreateFlagBits::eSparseBinding | ImageCreateFlagBits::eSparseResidency | ImageCreateFlagBits::eSparseAliased | ImageCreateFlagBits::eMutableFormat | + ImageCreateFlagBits::eCubeCompatible | ImageCreateFlagBits::eAlias | ImageCreateFlagBits::eSplitInstanceBindRegions | + ImageCreateFlagBits::e2DArrayCompatible | ImageCreateFlagBits::eBlockTexelViewCompatible | ImageCreateFlagBits::eExtendedUsage | + ImageCreateFlagBits::eProtected | ImageCreateFlagBits::eDisjoint | ImageCreateFlagBits::eCornerSampledNV | + ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT | + ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT | ImageCreateFlagBits::e2DViewCompatibleEXT | + ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM; + }; + enum class ImageTiling { eOptimal = VK_IMAGE_TILING_OPTIMAL, @@ -1531,11 +1575,41 @@ namespace VULKAN_HPP_NAMESPACE eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV }; + using ImageUsageFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageUsageFlags allFlags = + ImageUsageFlagBits::eTransferSrc | ImageUsageFlagBits::eTransferDst | ImageUsageFlagBits::eSampled | ImageUsageFlagBits::eStorage | + ImageUsageFlagBits::eColorAttachment | ImageUsageFlagBits::eDepthStencilAttachment | ImageUsageFlagBits::eTransientAttachment | + ImageUsageFlagBits::eInputAttachment +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | ImageUsageFlagBits::eVideoDecodeDstKHR | ImageUsageFlagBits::eVideoDecodeSrcKHR | ImageUsageFlagBits::eVideoDecodeDpbKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | ImageUsageFlagBits::eFragmentDensityMapEXT | ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | ImageUsageFlagBits::eVideoEncodeDstKHR | ImageUsageFlagBits::eVideoEncodeSrcKHR | ImageUsageFlagBits::eVideoEncodeDpbKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | ImageUsageFlagBits::eAttachmentFeedbackLoopEXT | ImageUsageFlagBits::eInvocationMaskHUAWEI | ImageUsageFlagBits::eSampleWeightQCOM | + ImageUsageFlagBits::eSampleBlockMatchQCOM; + }; + enum class InstanceCreateFlagBits : VkInstanceCreateFlags { eEnumeratePortabilityKHR = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR }; + using InstanceCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR InstanceCreateFlags allFlags = InstanceCreateFlagBits::eEnumeratePortabilityKHR; + }; + enum class InternalAllocationType { eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE @@ -1548,6 +1622,15 @@ namespace VULKAN_HPP_NAMESPACE eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR }; + using MemoryHeapFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryHeapFlags allFlags = MemoryHeapFlagBits::eDeviceLocal | MemoryHeapFlagBits::eMultiInstance; + }; + enum class MemoryPropertyFlagBits : VkMemoryPropertyFlags { eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, @@ -1561,6 +1644,18 @@ namespace VULKAN_HPP_NAMESPACE eRdmaCapableNV = VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV }; + using MemoryPropertyFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryPropertyFlags allFlags = + MemoryPropertyFlagBits::eDeviceLocal | MemoryPropertyFlagBits::eHostVisible | MemoryPropertyFlagBits::eHostCoherent | + MemoryPropertyFlagBits::eHostCached | MemoryPropertyFlagBits::eLazilyAllocated | MemoryPropertyFlagBits::eProtected | + MemoryPropertyFlagBits::eDeviceCoherentAMD | MemoryPropertyFlagBits::eDeviceUncachedAMD | MemoryPropertyFlagBits::eRdmaCapableNV; + }; + enum class PhysicalDeviceType { eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER, @@ -1584,6 +1679,20 @@ namespace VULKAN_HPP_NAMESPACE eOpticalFlowNV = VK_QUEUE_OPTICAL_FLOW_BIT_NV }; + using QueueFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueueFlags allFlags = QueueFlagBits::eGraphics | QueueFlagBits::eCompute | QueueFlagBits::eTransfer | + QueueFlagBits::eSparseBinding | QueueFlagBits::eProtected +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | QueueFlagBits::eVideoDecodeKHR | QueueFlagBits::eVideoEncodeKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | QueueFlagBits::eOpticalFlowNV; + }; + enum class SampleCountFlagBits : VkSampleCountFlags { e1 = VK_SAMPLE_COUNT_1_BIT, @@ -1595,6 +1704,17 @@ namespace VULKAN_HPP_NAMESPACE e64 = VK_SAMPLE_COUNT_64_BIT }; + using SampleCountFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SampleCountFlags allFlags = SampleCountFlagBits::e1 | SampleCountFlagBits::e2 | SampleCountFlagBits::e4 | + SampleCountFlagBits::e8 | SampleCountFlagBits::e16 | SampleCountFlagBits::e32 | + SampleCountFlagBits::e64; + }; + enum class SystemAllocationScope { eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, @@ -1604,10 +1724,19 @@ namespace VULKAN_HPP_NAMESPACE eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE }; - enum class DeviceCreateFlagBits + enum class DeviceCreateFlagBits : VkDeviceCreateFlags { }; + using DeviceCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceCreateFlags allFlags = {}; + }; + enum class PipelineStageFlagBits : VkPipelineStageFlags { eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, @@ -1645,10 +1774,37 @@ namespace VULKAN_HPP_NAMESPACE eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV }; + using PipelineStageFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags allFlags = + PipelineStageFlagBits::eTopOfPipe | PipelineStageFlagBits::eDrawIndirect | PipelineStageFlagBits::eVertexInput | PipelineStageFlagBits::eVertexShader | + PipelineStageFlagBits::eTessellationControlShader | PipelineStageFlagBits::eTessellationEvaluationShader | PipelineStageFlagBits::eGeometryShader | + PipelineStageFlagBits::eFragmentShader | PipelineStageFlagBits::eEarlyFragmentTests | PipelineStageFlagBits::eLateFragmentTests | + PipelineStageFlagBits::eColorAttachmentOutput | PipelineStageFlagBits::eComputeShader | PipelineStageFlagBits::eTransfer | + PipelineStageFlagBits::eBottomOfPipe | PipelineStageFlagBits::eHost | PipelineStageFlagBits::eAllGraphics | PipelineStageFlagBits::eAllCommands | + PipelineStageFlagBits::eNone | PipelineStageFlagBits::eTransformFeedbackEXT | PipelineStageFlagBits::eConditionalRenderingEXT | + PipelineStageFlagBits::eAccelerationStructureBuildKHR | PipelineStageFlagBits::eRayTracingShaderKHR | PipelineStageFlagBits::eFragmentDensityProcessEXT | + PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits::eCommandPreprocessNV | PipelineStageFlagBits::eTaskShaderEXT | + PipelineStageFlagBits::eMeshShaderEXT; + }; + enum class MemoryMapFlagBits : VkMemoryMapFlags { }; + using MemoryMapFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryMapFlags allFlags = {}; + }; + enum class ImageAspectFlagBits : VkImageAspectFlags { eColor = VK_IMAGE_ASPECT_COLOR_BIT, @@ -1669,6 +1825,19 @@ namespace VULKAN_HPP_NAMESPACE ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR }; + using ImageAspectFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageAspectFlags allFlags = ImageAspectFlagBits::eColor | ImageAspectFlagBits::eDepth | ImageAspectFlagBits::eStencil | + ImageAspectFlagBits::eMetadata | ImageAspectFlagBits::ePlane0 | + ImageAspectFlagBits::ePlane1 | ImageAspectFlagBits::ePlane2 | ImageAspectFlagBits::eNone | + ImageAspectFlagBits::eMemoryPlane0EXT | ImageAspectFlagBits::eMemoryPlane1EXT | + ImageAspectFlagBits::eMemoryPlane2EXT | ImageAspectFlagBits::eMemoryPlane3EXT; + }; + enum class SparseImageFormatFlagBits : VkSparseImageFormatFlags { eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, @@ -1676,26 +1845,72 @@ namespace VULKAN_HPP_NAMESPACE eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT }; + using SparseImageFormatFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SparseImageFormatFlags allFlags = + SparseImageFormatFlagBits::eSingleMiptail | SparseImageFormatFlagBits::eAlignedMipSize | SparseImageFormatFlagBits::eNonstandardBlockSize; + }; + enum class SparseMemoryBindFlagBits : VkSparseMemoryBindFlags { eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT }; + using SparseMemoryBindFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SparseMemoryBindFlags allFlags = SparseMemoryBindFlagBits::eMetadata; + }; + enum class FenceCreateFlagBits : VkFenceCreateFlags { eSignaled = VK_FENCE_CREATE_SIGNALED_BIT }; + using FenceCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FenceCreateFlags allFlags = FenceCreateFlagBits::eSignaled; + }; + enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags { }; + using SemaphoreCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreCreateFlags allFlags = {}; + }; + enum class EventCreateFlagBits : VkEventCreateFlags { eDeviceOnly = VK_EVENT_CREATE_DEVICE_ONLY_BIT, eDeviceOnlyKHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR }; + using EventCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR EventCreateFlags allFlags = EventCreateFlagBits::eDeviceOnly; + }; + enum class QueryPipelineStatisticFlagBits : VkQueryPipelineStatisticFlags { eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, @@ -1713,6 +1928,22 @@ namespace VULKAN_HPP_NAMESPACE eMeshShaderInvocationsEXT = VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT }; + using QueryPipelineStatisticFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPipelineStatisticFlags allFlags = + QueryPipelineStatisticFlagBits::eInputAssemblyVertices | QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives | + QueryPipelineStatisticFlagBits::eVertexShaderInvocations | QueryPipelineStatisticFlagBits::eGeometryShaderInvocations | + QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives | QueryPipelineStatisticFlagBits::eClippingInvocations | + QueryPipelineStatisticFlagBits::eClippingPrimitives | QueryPipelineStatisticFlagBits::eFragmentShaderInvocations | + QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches | QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations | + QueryPipelineStatisticFlagBits::eComputeShaderInvocations | QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT | + QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT; + }; + enum class QueryResultFlagBits : VkQueryResultFlags { e64 = VK_QUERY_RESULT_64_BIT, @@ -1724,6 +1955,20 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; + using QueryResultFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueryResultFlags allFlags = QueryResultFlagBits::e64 | QueryResultFlagBits::eWait | + QueryResultFlagBits::eWithAvailability | QueryResultFlagBits::ePartial +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | QueryResultFlagBits::eWithStatusKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ; + }; + enum class QueryType { eOcclusion = VK_QUERY_TYPE_OCCLUSION, @@ -1749,10 +1994,19 @@ namespace VULKAN_HPP_NAMESPACE eMicromapCompactedSizeEXT = VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT }; - enum class QueryPoolCreateFlagBits + enum class QueryPoolCreateFlagBits : VkQueryPoolCreateFlags { }; + using QueryPoolCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPoolCreateFlags allFlags = {}; + }; + enum class BufferCreateFlagBits : VkBufferCreateFlags { eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, @@ -1764,6 +2018,17 @@ namespace VULKAN_HPP_NAMESPACE eDeviceAddressCaptureReplayKHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR }; + using BufferCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BufferCreateFlags allFlags = BufferCreateFlagBits::eSparseBinding | BufferCreateFlagBits::eSparseResidency | + BufferCreateFlagBits::eSparseAliased | BufferCreateFlagBits::eProtected | + BufferCreateFlagBits::eDeviceAddressCaptureReplay; + }; + enum class BufferUsageFlagBits : VkBufferUsageFlags { eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, @@ -1797,6 +2062,28 @@ namespace VULKAN_HPP_NAMESPACE eShaderDeviceAddressKHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR }; + using BufferUsageFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BufferUsageFlags allFlags = + BufferUsageFlagBits::eTransferSrc | BufferUsageFlagBits::eTransferDst | BufferUsageFlagBits::eUniformTexelBuffer | + BufferUsageFlagBits::eStorageTexelBuffer | BufferUsageFlagBits::eUniformBuffer | BufferUsageFlagBits::eStorageBuffer | BufferUsageFlagBits::eIndexBuffer | + BufferUsageFlagBits::eVertexBuffer | BufferUsageFlagBits::eIndirectBuffer | BufferUsageFlagBits::eShaderDeviceAddress +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | BufferUsageFlagBits::eVideoDecodeSrcKHR | BufferUsageFlagBits::eVideoDecodeDstKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | BufferUsageFlagBits::eTransformFeedbackBufferEXT | BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT | + BufferUsageFlagBits::eConditionalRenderingEXT | BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR | + BufferUsageFlagBits::eAccelerationStructureStorageKHR | BufferUsageFlagBits::eShaderBindingTableKHR +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | BufferUsageFlagBits::eVideoEncodeDstKHR | BufferUsageFlagBits::eVideoEncodeSrcKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits::eMicromapStorageEXT; + }; + enum class SharingMode { eExclusive = VK_SHARING_MODE_EXCLUSIVE, @@ -1807,6 +2094,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using BufferViewCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BufferViewCreateFlags allFlags = {}; + }; + enum class ImageLayout { eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, @@ -1869,6 +2165,16 @@ namespace VULKAN_HPP_NAMESPACE eFragmentDensityMapDeferredEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT }; + using ImageViewCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageViewCreateFlags allFlags = + ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT | ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT; + }; + enum class ImageViewType { e1D = VK_IMAGE_VIEW_TYPE_1D, @@ -1884,6 +2190,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using ShaderModuleCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderModuleCreateFlags allFlags = {}; + }; + enum class BlendFactor { eZero = VK_BLEND_FACTOR_ZERO, @@ -1970,6 +2285,16 @@ namespace VULKAN_HPP_NAMESPACE eA = VK_COLOR_COMPONENT_A_BIT }; + using ColorComponentFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ColorComponentFlags allFlags = + ColorComponentFlagBits::eR | ColorComponentFlagBits::eG | ColorComponentFlagBits::eB | ColorComponentFlagBits::eA; + }; + enum class CompareOp { eNever = VK_COMPARE_OP_NEVER, @@ -1990,6 +2315,16 @@ namespace VULKAN_HPP_NAMESPACE eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK }; + using CullModeFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CullModeFlags allFlags = + CullModeFlagBits::eNone | CullModeFlagBits::eFront | CullModeFlagBits::eBack | CullModeFlagBits::eFrontAndBack; + }; + enum class DynamicState { eViewport = VK_DYNAMIC_STATE_VIEWPORT, @@ -2142,6 +2477,27 @@ namespace VULKAN_HPP_NAMESPACE eVkPipelineRasterizationStateCreateFragmentShadingRateAttachmentKHR = VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR }; + using PipelineCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreateFlags allFlags = + PipelineCreateFlagBits::eDisableOptimization | PipelineCreateFlagBits::eAllowDerivatives | PipelineCreateFlagBits::eDerivative | + PipelineCreateFlagBits::eViewIndexFromDeviceIndex | PipelineCreateFlagBits::eDispatchBase | PipelineCreateFlagBits::eFailOnPipelineCompileRequired | + PipelineCreateFlagBits::eEarlyReturnOnFailure | PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR | + PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR | + PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR | PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR | + PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR | PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR | + PipelineCreateFlagBits::eRayTracingSkipAabbsKHR | PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR | + PipelineCreateFlagBits::eDeferCompileNV | PipelineCreateFlagBits::eCaptureStatisticsKHR | PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR | + PipelineCreateFlagBits::eIndirectBindableNV | PipelineCreateFlagBits::eLibraryKHR | PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT | + PipelineCreateFlagBits::eLinkTimeOptimizationEXT | PipelineCreateFlagBits::eRayTracingAllowMotionNV | + PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT | + PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT | PipelineCreateFlagBits::eNoProtectedAccessEXT | PipelineCreateFlagBits::eProtectedAccessOnlyEXT; + }; + enum class PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags { eAllowVaryingSubgroupSize = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, @@ -2150,6 +2506,16 @@ namespace VULKAN_HPP_NAMESPACE eRequireFullSubgroupsEXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT }; + using PipelineShaderStageCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineShaderStageCreateFlags allFlags = + PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize | PipelineShaderStageCreateFlagBits::eRequireFullSubgroups; + }; + enum class PolygonMode { eFill = VK_POLYGON_MODE_FILL, @@ -2202,6 +2568,20 @@ namespace VULKAN_HPP_NAMESPACE eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV }; + using ShaderStageFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderStageFlags allFlags = + ShaderStageFlagBits::eVertex | ShaderStageFlagBits::eTessellationControl | ShaderStageFlagBits::eTessellationEvaluation | ShaderStageFlagBits::eGeometry | + ShaderStageFlagBits::eFragment | ShaderStageFlagBits::eCompute | ShaderStageFlagBits::eAllGraphics | ShaderStageFlagBits::eAll | + ShaderStageFlagBits::eRaygenKHR | ShaderStageFlagBits::eAnyHitKHR | ShaderStageFlagBits::eClosestHitKHR | ShaderStageFlagBits::eMissKHR | + ShaderStageFlagBits::eIntersectionKHR | ShaderStageFlagBits::eCallableKHR | ShaderStageFlagBits::eTaskEXT | ShaderStageFlagBits::eMeshEXT | + ShaderStageFlagBits::eSubpassShadingHUAWEI; + }; + enum class StencilOp { eKeep = VK_STENCIL_OP_KEEP, @@ -2224,30 +2604,93 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineDynamicStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDynamicStateCreateFlags allFlags = {}; + }; + enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags { }; + using PipelineInputAssemblyStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineInputAssemblyStateCreateFlags allFlags = {}; + }; + enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags { }; + using PipelineMultisampleStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineMultisampleStateCreateFlags allFlags = {}; + }; + enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags { }; + using PipelineRasterizationStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationStateCreateFlags allFlags = {}; + }; + enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags { }; + using PipelineTessellationStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineTessellationStateCreateFlags allFlags = {}; + }; + enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags { }; + using PipelineVertexInputStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineVertexInputStateCreateFlags allFlags = {}; + }; + enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags { }; + using PipelineViewportStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineViewportStateCreateFlags allFlags = {}; + }; + enum class BorderColor { eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, @@ -2286,6 +2729,17 @@ namespace VULKAN_HPP_NAMESPACE eImageProcessingQCOM = VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM }; + using SamplerCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SamplerCreateFlags allFlags = + SamplerCreateFlagBits::eSubsampledEXT | SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT | SamplerCreateFlagBits::eNonSeamlessCubeMapEXT | + SamplerCreateFlagBits::eImageProcessingQCOM; + }; + enum class SamplerMipmapMode { eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST, @@ -2301,6 +2755,16 @@ namespace VULKAN_HPP_NAMESPACE eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT }; + using DescriptorPoolCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolCreateFlags allFlags = + DescriptorPoolCreateFlagBits::eFreeDescriptorSet | DescriptorPoolCreateFlagBits::eUpdateAfterBind | DescriptorPoolCreateFlagBits::eHostOnlyEXT; + }; + enum class DescriptorSetLayoutCreateFlagBits : VkDescriptorSetLayoutCreateFlags { eUpdateAfterBindPool = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, @@ -2310,6 +2774,17 @@ namespace VULKAN_HPP_NAMESPACE eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT }; + using DescriptorSetLayoutCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorSetLayoutCreateFlags allFlags = DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool | + DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR | + DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT; + }; + enum class DescriptorType { eSampler = VK_DESCRIPTOR_TYPE_SAMPLER, @@ -2337,6 +2812,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using DescriptorPoolResetFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolResetFlags allFlags = {}; + }; + enum class AccessFlagBits : VkAccessFlags { eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, @@ -2374,11 +2858,37 @@ namespace VULKAN_HPP_NAMESPACE eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV }; + using AccessFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags allFlags = + AccessFlagBits::eIndirectCommandRead | AccessFlagBits::eIndexRead | AccessFlagBits::eVertexAttributeRead | AccessFlagBits::eUniformRead | + AccessFlagBits::eInputAttachmentRead | AccessFlagBits::eShaderRead | AccessFlagBits::eShaderWrite | AccessFlagBits::eColorAttachmentRead | + AccessFlagBits::eColorAttachmentWrite | AccessFlagBits::eDepthStencilAttachmentRead | AccessFlagBits::eDepthStencilAttachmentWrite | + AccessFlagBits::eTransferRead | AccessFlagBits::eTransferWrite | AccessFlagBits::eHostRead | AccessFlagBits::eHostWrite | AccessFlagBits::eMemoryRead | + AccessFlagBits::eMemoryWrite | AccessFlagBits::eNone | AccessFlagBits::eTransformFeedbackWriteEXT | AccessFlagBits::eTransformFeedbackCounterReadEXT | + AccessFlagBits::eTransformFeedbackCounterWriteEXT | AccessFlagBits::eConditionalRenderingReadEXT | AccessFlagBits::eColorAttachmentReadNoncoherentEXT | + AccessFlagBits::eAccelerationStructureReadKHR | AccessFlagBits::eAccelerationStructureWriteKHR | AccessFlagBits::eFragmentDensityMapReadEXT | + AccessFlagBits::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits::eCommandPreprocessReadNV | AccessFlagBits::eCommandPreprocessWriteNV; + }; + enum class AttachmentDescriptionFlagBits : VkAttachmentDescriptionFlags { eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT }; + using AttachmentDescriptionFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AttachmentDescriptionFlags allFlags = AttachmentDescriptionFlagBits::eMayAlias; + }; + enum class AttachmentLoadOp { eLoad = VK_ATTACHMENT_LOAD_OP_LOAD, @@ -2407,12 +2917,31 @@ namespace VULKAN_HPP_NAMESPACE eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR }; + using DependencyFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DependencyFlags allFlags = + DependencyFlagBits::eByRegion | DependencyFlagBits::eDeviceGroup | DependencyFlagBits::eViewLocal | DependencyFlagBits::eFeedbackLoopEXT; + }; + enum class FramebufferCreateFlagBits : VkFramebufferCreateFlags { eImageless = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, eImagelessKHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR }; + using FramebufferCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FramebufferCreateFlags allFlags = FramebufferCreateFlagBits::eImageless; + }; + enum class PipelineBindPoint { eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, @@ -2427,6 +2956,15 @@ namespace VULKAN_HPP_NAMESPACE eTransformQCOM = VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM }; + using RenderPassCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR RenderPassCreateFlags allFlags = RenderPassCreateFlagBits::eTransformQCOM; + }; + enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags { ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, @@ -2442,6 +2980,19 @@ namespace VULKAN_HPP_NAMESPACE eRasterizationOrderAttachmentStencilAccessARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM }; + using SubpassDescriptionFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SubpassDescriptionFlags allFlags = + SubpassDescriptionFlagBits::ePerViewAttributesNVX | SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX | + SubpassDescriptionFlagBits::eFragmentRegionQCOM | SubpassDescriptionFlagBits::eShaderResolveQCOM | + SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT | + SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT | SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT; + }; + enum class CommandPoolCreateFlagBits : VkCommandPoolCreateFlags { eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, @@ -2449,11 +3000,30 @@ namespace VULKAN_HPP_NAMESPACE eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT }; + using CommandPoolCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolCreateFlags allFlags = + CommandPoolCreateFlagBits::eTransient | CommandPoolCreateFlagBits::eResetCommandBuffer | CommandPoolCreateFlagBits::eProtected; + }; + enum class CommandPoolResetFlagBits : VkCommandPoolResetFlags { eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT }; + using CommandPoolResetFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolResetFlags allFlags = CommandPoolResetFlagBits::eReleaseResources; + }; + enum class CommandBufferLevel { ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY, @@ -2465,6 +3035,15 @@ namespace VULKAN_HPP_NAMESPACE eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT }; + using CommandBufferResetFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferResetFlags allFlags = CommandBufferResetFlagBits::eReleaseResources; + }; + enum class CommandBufferUsageFlagBits : VkCommandBufferUsageFlags { eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, @@ -2472,11 +3051,30 @@ namespace VULKAN_HPP_NAMESPACE eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT }; + using CommandBufferUsageFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferUsageFlags allFlags = + CommandBufferUsageFlagBits::eOneTimeSubmit | CommandBufferUsageFlagBits::eRenderPassContinue | CommandBufferUsageFlagBits::eSimultaneousUse; + }; + enum class QueryControlFlagBits : VkQueryControlFlags { ePrecise = VK_QUERY_CONTROL_PRECISE_BIT }; + using QueryControlFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueryControlFlags allFlags = QueryControlFlagBits::ePrecise; + }; + enum class IndexType { eUint16 = VK_INDEX_TYPE_UINT16, @@ -2494,6 +3092,16 @@ namespace VULKAN_HPP_NAMESPACE eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK }; + using StencilFaceFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StencilFaceFlags allFlags = + StencilFaceFlagBits::eFront | StencilFaceFlagBits::eBack | StencilFaceFlagBits::eFrontAndBack; + }; + enum class SubpassContents { eInline = VK_SUBPASS_CONTENTS_INLINE, @@ -2515,6 +3123,18 @@ namespace VULKAN_HPP_NAMESPACE ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV }; + using SubgroupFeatureFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SubgroupFeatureFlags allFlags = + SubgroupFeatureFlagBits::eBasic | SubgroupFeatureFlagBits::eVote | SubgroupFeatureFlagBits::eArithmetic | SubgroupFeatureFlagBits::eBallot | + SubgroupFeatureFlagBits::eShuffle | SubgroupFeatureFlagBits::eShuffleRelative | SubgroupFeatureFlagBits::eClustered | SubgroupFeatureFlagBits::eQuad | + SubgroupFeatureFlagBits::ePartitionedNV; + }; + enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags { eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, @@ -2524,6 +3144,17 @@ namespace VULKAN_HPP_NAMESPACE }; using PeerMemoryFeatureFlagBitsKHR = PeerMemoryFeatureFlagBits; + using PeerMemoryFeatureFlags = Flags; + using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PeerMemoryFeatureFlags allFlags = PeerMemoryFeatureFlagBits::eCopySrc | PeerMemoryFeatureFlagBits::eCopyDst | + PeerMemoryFeatureFlagBits::eGenericSrc | PeerMemoryFeatureFlagBits::eGenericDst; + }; + enum class MemoryAllocateFlagBits : VkMemoryAllocateFlags { eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, @@ -2532,10 +3163,31 @@ namespace VULKAN_HPP_NAMESPACE }; using MemoryAllocateFlagBitsKHR = MemoryAllocateFlagBits; + using MemoryAllocateFlags = Flags; + using MemoryAllocateFlagsKHR = MemoryAllocateFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryAllocateFlags allFlags = + MemoryAllocateFlagBits::eDeviceMask | MemoryAllocateFlagBits::eDeviceAddress | MemoryAllocateFlagBits::eDeviceAddressCaptureReplay; + }; + enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags { }; + using CommandPoolTrimFlags = Flags; + using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolTrimFlags allFlags = {}; + }; + enum class PointClippingBehavior { eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, @@ -2555,6 +3207,15 @@ namespace VULKAN_HPP_NAMESPACE eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT }; + using DeviceQueueCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = DeviceQueueCreateFlagBits::eProtected; + }; + enum class SamplerYcbcrModelConversion { eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, @@ -2590,6 +3251,16 @@ namespace VULKAN_HPP_NAMESPACE { }; + using DescriptorUpdateTemplateCreateFlags = Flags; + using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorUpdateTemplateCreateFlags allFlags = {}; + }; + enum class ExternalMemoryHandleTypeFlagBits : VkExternalMemoryHandleTypeFlags { eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, @@ -2612,6 +3283,27 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalMemoryHandleTypeFlagBitsKHR = ExternalMemoryHandleTypeFlagBits; + using ExternalMemoryHandleTypeFlags = Flags; + using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlags allFlags = + ExternalMemoryHandleTypeFlagBits::eOpaqueFd | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt | + ExternalMemoryHandleTypeFlagBits::eD3D11Texture | ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt | ExternalMemoryHandleTypeFlagBits::eD3D12Heap | + ExternalMemoryHandleTypeFlagBits::eD3D12Resource | ExternalMemoryHandleTypeFlagBits::eDmaBufEXT +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + | ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + | ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT | ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT +#if defined( VK_USE_PLATFORM_FUCHSIA ) + | ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + | ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV; + }; + enum class ExternalMemoryFeatureFlagBits : VkExternalMemoryFeatureFlags { eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, @@ -2620,6 +3312,17 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalMemoryFeatureFlagBitsKHR = ExternalMemoryFeatureFlagBits; + using ExternalMemoryFeatureFlags = Flags; + using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlags allFlags = + ExternalMemoryFeatureFlagBits::eDedicatedOnly | ExternalMemoryFeatureFlagBits::eExportable | ExternalMemoryFeatureFlagBits::eImportable; + }; + enum class ExternalFenceHandleTypeFlagBits : VkExternalFenceHandleTypeFlags { eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, @@ -2629,6 +3332,18 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalFenceHandleTypeFlagBitsKHR = ExternalFenceHandleTypeFlagBits; + using ExternalFenceHandleTypeFlags = Flags; + using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceHandleTypeFlags allFlags = + ExternalFenceHandleTypeFlagBits::eOpaqueFd | ExternalFenceHandleTypeFlagBits::eOpaqueWin32 | ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt | + ExternalFenceHandleTypeFlagBits::eSyncFd; + }; + enum class ExternalFenceFeatureFlagBits : VkExternalFenceFeatureFlags { eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, @@ -2636,18 +3351,49 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalFenceFeatureFlagBitsKHR = ExternalFenceFeatureFlagBits; + using ExternalFenceFeatureFlags = Flags; + using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceFeatureFlags allFlags = + ExternalFenceFeatureFlagBits::eExportable | ExternalFenceFeatureFlagBits::eImportable; + }; + enum class FenceImportFlagBits : VkFenceImportFlags { eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT }; using FenceImportFlagBitsKHR = FenceImportFlagBits; + using FenceImportFlags = Flags; + using FenceImportFlagsKHR = FenceImportFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FenceImportFlags allFlags = FenceImportFlagBits::eTemporary; + }; + enum class SemaphoreImportFlagBits : VkSemaphoreImportFlags { eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT }; using SemaphoreImportFlagBitsKHR = SemaphoreImportFlagBits; + using SemaphoreImportFlags = Flags; + using SemaphoreImportFlagsKHR = SemaphoreImportFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreImportFlags allFlags = SemaphoreImportFlagBits::eTemporary; + }; + enum class ExternalSemaphoreHandleTypeFlagBits : VkExternalSemaphoreHandleTypeFlags { eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, @@ -2662,6 +3408,22 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalSemaphoreHandleTypeFlagBitsKHR = ExternalSemaphoreHandleTypeFlagBits; + using ExternalSemaphoreHandleTypeFlags = Flags; + using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreHandleTypeFlags allFlags = + ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd | ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 | + ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt | ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence | ExternalSemaphoreHandleTypeFlagBits::eSyncFd +#if defined( VK_USE_PLATFORM_FUCHSIA ) + | ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + ; + }; + enum class ExternalSemaphoreFeatureFlagBits : VkExternalSemaphoreFeatureFlags { eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, @@ -2669,6 +3431,17 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalSemaphoreFeatureFlagBitsKHR = ExternalSemaphoreFeatureFlagBits; + using ExternalSemaphoreFeatureFlags = Flags; + using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreFeatureFlags allFlags = + ExternalSemaphoreFeatureFlagBits::eExportable | ExternalSemaphoreFeatureFlagBits::eImportable; + }; + //=== VK_VERSION_1_2 === enum class DriverId @@ -2716,6 +3489,18 @@ namespace VULKAN_HPP_NAMESPACE }; using DescriptorBindingFlagBitsEXT = DescriptorBindingFlagBits; + using DescriptorBindingFlags = Flags; + using DescriptorBindingFlagsEXT = DescriptorBindingFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorBindingFlags allFlags = + DescriptorBindingFlagBits::eUpdateAfterBind | DescriptorBindingFlagBits::eUpdateUnusedWhilePending | DescriptorBindingFlagBits::ePartiallyBound | + DescriptorBindingFlagBits::eVariableDescriptorCount; + }; + enum class ResolveModeFlagBits : VkResolveModeFlags { eNone = VK_RESOLVE_MODE_NONE, @@ -2726,6 +3511,17 @@ namespace VULKAN_HPP_NAMESPACE }; using ResolveModeFlagBitsKHR = ResolveModeFlagBits; + using ResolveModeFlags = Flags; + using ResolveModeFlagsKHR = ResolveModeFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags = + ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero | ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax; + }; + enum class SamplerReductionMode { eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, @@ -2747,6 +3543,16 @@ namespace VULKAN_HPP_NAMESPACE }; using SemaphoreWaitFlagBitsKHR = SemaphoreWaitFlagBits; + using SemaphoreWaitFlags = Flags; + using SemaphoreWaitFlagsKHR = SemaphoreWaitFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreWaitFlags allFlags = SemaphoreWaitFlagBits::eAny; + }; + //=== VK_VERSION_1_3 === enum class PipelineCreationFeedbackFlagBits : VkPipelineCreationFeedbackFlags @@ -2757,6 +3563,18 @@ namespace VULKAN_HPP_NAMESPACE }; using PipelineCreationFeedbackFlagBitsEXT = PipelineCreationFeedbackFlagBits; + using PipelineCreationFeedbackFlags = Flags; + using PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreationFeedbackFlags allFlags = PipelineCreationFeedbackFlagBits::eValid | + PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit | + PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration; + }; + enum class ToolPurposeFlagBits : VkToolPurposeFlags { eValidation = VK_TOOL_PURPOSE_VALIDATION_BIT, @@ -2769,11 +3587,33 @@ namespace VULKAN_HPP_NAMESPACE }; using ToolPurposeFlagBitsEXT = ToolPurposeFlagBits; + using ToolPurposeFlags = Flags; + using ToolPurposeFlagsEXT = ToolPurposeFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ToolPurposeFlags allFlags = + ToolPurposeFlagBits::eValidation | ToolPurposeFlagBits::eProfiling | ToolPurposeFlagBits::eTracing | ToolPurposeFlagBits::eAdditionalFeatures | + ToolPurposeFlagBits::eModifyingFeatures | ToolPurposeFlagBits::eDebugReportingEXT | ToolPurposeFlagBits::eDebugMarkersEXT; + }; + enum class PrivateDataSlotCreateFlagBits : VkPrivateDataSlotCreateFlags { }; using PrivateDataSlotCreateFlagBitsEXT = PrivateDataSlotCreateFlagBits; + using PrivateDataSlotCreateFlags = Flags; + using PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PrivateDataSlotCreateFlags allFlags = {}; + }; + enum class PipelineStageFlagBits2 : VkPipelineStageFlags2 { eNone = VK_PIPELINE_STAGE_2_NONE, @@ -2828,6 +3668,32 @@ namespace VULKAN_HPP_NAMESPACE }; using PipelineStageFlagBits2KHR = PipelineStageFlagBits2; + using PipelineStageFlags2 = Flags; + using PipelineStageFlags2KHR = PipelineStageFlags2; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags2 allFlags = + PipelineStageFlagBits2::eNone | PipelineStageFlagBits2::eTopOfPipe | PipelineStageFlagBits2::eDrawIndirect | PipelineStageFlagBits2::eVertexInput | + PipelineStageFlagBits2::eVertexShader | PipelineStageFlagBits2::eTessellationControlShader | PipelineStageFlagBits2::eTessellationEvaluationShader | + PipelineStageFlagBits2::eGeometryShader | PipelineStageFlagBits2::eFragmentShader | PipelineStageFlagBits2::eEarlyFragmentTests | + PipelineStageFlagBits2::eLateFragmentTests | PipelineStageFlagBits2::eColorAttachmentOutput | PipelineStageFlagBits2::eComputeShader | + PipelineStageFlagBits2::eAllTransfer | PipelineStageFlagBits2::eBottomOfPipe | PipelineStageFlagBits2::eHost | PipelineStageFlagBits2::eAllGraphics | + PipelineStageFlagBits2::eAllCommands | PipelineStageFlagBits2::eCopy | PipelineStageFlagBits2::eResolve | PipelineStageFlagBits2::eBlit | + PipelineStageFlagBits2::eClear | PipelineStageFlagBits2::eIndexInput | PipelineStageFlagBits2::eVertexAttributeInput | + PipelineStageFlagBits2::ePreRasterizationShaders +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | PipelineStageFlagBits2::eVideoDecodeKHR | PipelineStageFlagBits2::eVideoEncodeKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | PipelineStageFlagBits2::eTransformFeedbackEXT | PipelineStageFlagBits2::eConditionalRenderingEXT | PipelineStageFlagBits2::eCommandPreprocessNV | + PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits2::eAccelerationStructureBuildKHR | + PipelineStageFlagBits2::eRayTracingShaderKHR | PipelineStageFlagBits2::eFragmentDensityProcessEXT | PipelineStageFlagBits2::eTaskShaderEXT | + PipelineStageFlagBits2::eMeshShaderEXT | PipelineStageFlagBits2::eSubpassShadingHUAWEI | PipelineStageFlagBits2::eInvocationMaskHUAWEI | + PipelineStageFlagBits2::eAccelerationStructureCopyKHR | PipelineStageFlagBits2::eMicromapBuildEXT | PipelineStageFlagBits2::eOpticalFlowNV; + }; + enum class AccessFlagBits2 : VkAccessFlags2 { eNone = VK_ACCESS_2_NONE, @@ -2880,12 +3746,48 @@ namespace VULKAN_HPP_NAMESPACE }; using AccessFlagBits2KHR = AccessFlagBits2; + using AccessFlags2 = Flags; + using AccessFlags2KHR = AccessFlags2; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags2 allFlags = + AccessFlagBits2::eNone | AccessFlagBits2::eIndirectCommandRead | AccessFlagBits2::eIndexRead | AccessFlagBits2::eVertexAttributeRead | + AccessFlagBits2::eUniformRead | AccessFlagBits2::eInputAttachmentRead | AccessFlagBits2::eShaderRead | AccessFlagBits2::eShaderWrite | + AccessFlagBits2::eColorAttachmentRead | AccessFlagBits2::eColorAttachmentWrite | AccessFlagBits2::eDepthStencilAttachmentRead | + AccessFlagBits2::eDepthStencilAttachmentWrite | AccessFlagBits2::eTransferRead | AccessFlagBits2::eTransferWrite | AccessFlagBits2::eHostRead | + AccessFlagBits2::eHostWrite | AccessFlagBits2::eMemoryRead | AccessFlagBits2::eMemoryWrite | AccessFlagBits2::eShaderSampledRead | + AccessFlagBits2::eShaderStorageRead | AccessFlagBits2::eShaderStorageWrite +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | AccessFlagBits2::eVideoDecodeReadKHR | AccessFlagBits2::eVideoDecodeWriteKHR | AccessFlagBits2::eVideoEncodeReadKHR | + AccessFlagBits2::eVideoEncodeWriteKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | AccessFlagBits2::eTransformFeedbackWriteEXT | AccessFlagBits2::eTransformFeedbackCounterReadEXT | AccessFlagBits2::eTransformFeedbackCounterWriteEXT | + AccessFlagBits2::eConditionalRenderingReadEXT | AccessFlagBits2::eCommandPreprocessReadNV | AccessFlagBits2::eCommandPreprocessWriteNV | + AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits2::eAccelerationStructureReadKHR | + AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT | AccessFlagBits2::eColorAttachmentReadNoncoherentEXT | + AccessFlagBits2::eInvocationMaskReadHUAWEI | AccessFlagBits2::eShaderBindingTableReadKHR | AccessFlagBits2::eMicromapReadEXT | + AccessFlagBits2::eMicromapWriteEXT | AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV; + }; + enum class SubmitFlagBits : VkSubmitFlags { eProtected = VK_SUBMIT_PROTECTED_BIT }; using SubmitFlagBitsKHR = SubmitFlagBits; + using SubmitFlags = Flags; + using SubmitFlagsKHR = SubmitFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SubmitFlags allFlags = SubmitFlagBits::eProtected; + }; + enum class RenderingFlagBits : VkRenderingFlags { eContentsSecondaryCommandBuffers = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, @@ -2895,6 +3797,17 @@ namespace VULKAN_HPP_NAMESPACE }; using RenderingFlagBitsKHR = RenderingFlagBits; + using RenderingFlags = Flags; + using RenderingFlagsKHR = RenderingFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = RenderingFlagBits::eContentsSecondaryCommandBuffers | RenderingFlagBits::eSuspending | + RenderingFlagBits::eResuming | RenderingFlagBits::eEnableLegacyDitheringEXT; + }; + enum class FormatFeatureFlagBits2 : VkFormatFeatureFlags2 { eSampledImage = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, @@ -2948,6 +3861,38 @@ namespace VULKAN_HPP_NAMESPACE }; using FormatFeatureFlagBits2KHR = FormatFeatureFlagBits2; + using FormatFeatureFlags2 = Flags; + using FormatFeatureFlags2KHR = FormatFeatureFlags2; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags2 allFlags = + FormatFeatureFlagBits2::eSampledImage | FormatFeatureFlagBits2::eStorageImage | FormatFeatureFlagBits2::eStorageImageAtomic | + FormatFeatureFlagBits2::eUniformTexelBuffer | FormatFeatureFlagBits2::eStorageTexelBuffer | FormatFeatureFlagBits2::eStorageTexelBufferAtomic | + FormatFeatureFlagBits2::eVertexBuffer | FormatFeatureFlagBits2::eColorAttachment | FormatFeatureFlagBits2::eColorAttachmentBlend | + FormatFeatureFlagBits2::eDepthStencilAttachment | FormatFeatureFlagBits2::eBlitSrc | FormatFeatureFlagBits2::eBlitDst | + FormatFeatureFlagBits2::eSampledImageFilterLinear | FormatFeatureFlagBits2::eSampledImageFilterCubic | FormatFeatureFlagBits2::eTransferSrc | + FormatFeatureFlagBits2::eTransferDst | FormatFeatureFlagBits2::eSampledImageFilterMinmax | FormatFeatureFlagBits2::eMidpointChromaSamples | + FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter | FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter | + FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit | + FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable | FormatFeatureFlagBits2::eDisjoint | + FormatFeatureFlagBits2::eCositedChromaSamples | FormatFeatureFlagBits2::eStorageReadWithoutFormat | FormatFeatureFlagBits2::eStorageWriteWithoutFormat | + FormatFeatureFlagBits2::eSampledImageDepthComparison +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | FormatFeatureFlagBits2::eVideoDecodeOutputKHR | FormatFeatureFlagBits2::eVideoDecodeDpbKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR | FormatFeatureFlagBits2::eFragmentDensityMapEXT | + FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | FormatFeatureFlagBits2::eVideoEncodeInputKHR | FormatFeatureFlagBits2::eVideoEncodeDpbKHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | FormatFeatureFlagBits2::eLinearColorAttachmentNV | FormatFeatureFlagBits2::eWeightImageQCOM | FormatFeatureFlagBits2::eWeightSampledImageQCOM | + FormatFeatureFlagBits2::eBlockMatchingQCOM | FormatFeatureFlagBits2::eBoxFilterSampledQCOM | FormatFeatureFlagBits2::eOpticalFlowImageNV | + FormatFeatureFlagBits2::eOpticalFlowVectorNV | FormatFeatureFlagBits2::eOpticalFlowCostNV; + }; + //=== VK_KHR_surface === enum class SurfaceTransformFlagBitsKHR : VkSurfaceTransformFlagsKHR @@ -2963,6 +3908,18 @@ namespace VULKAN_HPP_NAMESPACE eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR }; + using SurfaceTransformFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceTransformFlagsKHR allFlags = + SurfaceTransformFlagBitsKHR::eIdentity | SurfaceTransformFlagBitsKHR::eRotate90 | SurfaceTransformFlagBitsKHR::eRotate180 | + SurfaceTransformFlagBitsKHR::eRotate270 | SurfaceTransformFlagBitsKHR::eHorizontalMirror | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 | + SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 | SurfaceTransformFlagBitsKHR::eInherit; + }; + enum class PresentModeKHR { eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, @@ -3003,6 +3960,16 @@ namespace VULKAN_HPP_NAMESPACE eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR }; + using CompositeAlphaFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CompositeAlphaFlagsKHR allFlags = CompositeAlphaFlagBitsKHR::eOpaque | CompositeAlphaFlagBitsKHR::ePreMultiplied | + CompositeAlphaFlagBitsKHR::ePostMultiplied | CompositeAlphaFlagBitsKHR::eInherit; + }; + //=== VK_KHR_swapchain === enum class SwapchainCreateFlagBitsKHR : VkSwapchainCreateFlagsKHR @@ -3012,6 +3979,16 @@ namespace VULKAN_HPP_NAMESPACE eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR }; + using SwapchainCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SwapchainCreateFlagsKHR allFlags = + SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions | SwapchainCreateFlagBitsKHR::eProtected | SwapchainCreateFlagBitsKHR::eMutableFormat; + }; + enum class DeviceGroupPresentModeFlagBitsKHR : VkDeviceGroupPresentModeFlagsKHR { eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, @@ -3020,6 +3997,17 @@ namespace VULKAN_HPP_NAMESPACE eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR }; + using DeviceGroupPresentModeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceGroupPresentModeFlagsKHR allFlags = + DeviceGroupPresentModeFlagBitsKHR::eLocal | DeviceGroupPresentModeFlagBitsKHR::eRemote | DeviceGroupPresentModeFlagBitsKHR::eSum | + DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice; + }; + //=== VK_KHR_display === enum class DisplayPlaneAlphaFlagBitsKHR : VkDisplayPlaneAlphaFlagsKHR @@ -3030,20 +4018,58 @@ namespace VULKAN_HPP_NAMESPACE ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR }; + using DisplayPlaneAlphaFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayPlaneAlphaFlagsKHR allFlags = DisplayPlaneAlphaFlagBitsKHR::eOpaque | DisplayPlaneAlphaFlagBitsKHR::eGlobal | + DisplayPlaneAlphaFlagBitsKHR::ePerPixel | + DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied; + }; + enum class DisplayModeCreateFlagBitsKHR : VkDisplayModeCreateFlagsKHR { }; + using DisplayModeCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayModeCreateFlagsKHR allFlags = {}; + }; + enum class DisplaySurfaceCreateFlagBitsKHR : VkDisplaySurfaceCreateFlagsKHR { }; + using DisplaySurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DisplaySurfaceCreateFlagsKHR allFlags = {}; + }; + #if defined( VK_USE_PLATFORM_XLIB_KHR ) //=== VK_KHR_xlib_surface === enum class XlibSurfaceCreateFlagBitsKHR : VkXlibSurfaceCreateFlagsKHR { }; + + using XlibSurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR XlibSurfaceCreateFlagsKHR allFlags = {}; + }; #endif /*VK_USE_PLATFORM_XLIB_KHR*/ #if defined( VK_USE_PLATFORM_XCB_KHR ) @@ -3052,6 +4078,15 @@ namespace VULKAN_HPP_NAMESPACE enum class XcbSurfaceCreateFlagBitsKHR : VkXcbSurfaceCreateFlagsKHR { }; + + using XcbSurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR XcbSurfaceCreateFlagsKHR allFlags = {}; + }; #endif /*VK_USE_PLATFORM_XCB_KHR*/ #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) @@ -3060,6 +4095,15 @@ namespace VULKAN_HPP_NAMESPACE enum class WaylandSurfaceCreateFlagBitsKHR : VkWaylandSurfaceCreateFlagsKHR { }; + + using WaylandSurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR WaylandSurfaceCreateFlagsKHR allFlags = {}; + }; #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) @@ -3068,6 +4112,15 @@ namespace VULKAN_HPP_NAMESPACE enum class AndroidSurfaceCreateFlagBitsKHR : VkAndroidSurfaceCreateFlagsKHR { }; + + using AndroidSurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AndroidSurfaceCreateFlagsKHR allFlags = {}; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -3076,6 +4129,15 @@ namespace VULKAN_HPP_NAMESPACE enum class Win32SurfaceCreateFlagBitsKHR : VkWin32SurfaceCreateFlagsKHR { }; + + using Win32SurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR Win32SurfaceCreateFlagsKHR allFlags = {}; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_EXT_debug_report === @@ -3089,6 +4151,17 @@ namespace VULKAN_HPP_NAMESPACE eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT }; + using DebugReportFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportFlagsEXT allFlags = DebugReportFlagBitsEXT::eInformation | DebugReportFlagBitsEXT::eWarning | + DebugReportFlagBitsEXT::ePerformanceWarning | DebugReportFlagBitsEXT::eError | + DebugReportFlagBitsEXT::eDebug; + }; + enum class DebugReportObjectTypeEXT { eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, @@ -3158,6 +4231,17 @@ namespace VULKAN_HPP_NAMESPACE eDecodeH265EXT = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT }; + using VideoCodecOperationFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodecOperationFlagsKHR allFlags = + VideoCodecOperationFlagBitsKHR::eNone | VideoCodecOperationFlagBitsKHR::eEncodeH264EXT | VideoCodecOperationFlagBitsKHR::eEncodeH265EXT | + VideoCodecOperationFlagBitsKHR::eDecodeH264EXT | VideoCodecOperationFlagBitsKHR::eDecodeH265EXT; + }; + enum class VideoChromaSubsamplingFlagBitsKHR : VkVideoChromaSubsamplingFlagsKHR { eInvalid = VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR, @@ -3167,6 +4251,17 @@ namespace VULKAN_HPP_NAMESPACE e444 = VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR }; + using VideoChromaSubsamplingFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoChromaSubsamplingFlagsKHR allFlags = + VideoChromaSubsamplingFlagBitsKHR::eInvalid | VideoChromaSubsamplingFlagBitsKHR::eMonochrome | VideoChromaSubsamplingFlagBitsKHR::e420 | + VideoChromaSubsamplingFlagBitsKHR::e422 | VideoChromaSubsamplingFlagBitsKHR::e444; + }; + enum class VideoComponentBitDepthFlagBitsKHR : VkVideoComponentBitDepthFlagsKHR { eInvalid = VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR, @@ -3175,17 +4270,47 @@ namespace VULKAN_HPP_NAMESPACE e12 = VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR }; + using VideoComponentBitDepthFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoComponentBitDepthFlagsKHR allFlags = + VideoComponentBitDepthFlagBitsKHR::eInvalid | VideoComponentBitDepthFlagBitsKHR::e8 | VideoComponentBitDepthFlagBitsKHR::e10 | + VideoComponentBitDepthFlagBitsKHR::e12; + }; + enum class VideoCapabilityFlagBitsKHR : VkVideoCapabilityFlagsKHR { eProtectedContent = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR, eSeparateReferenceImages = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR }; + using VideoCapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCapabilityFlagsKHR allFlags = + VideoCapabilityFlagBitsKHR::eProtectedContent | VideoCapabilityFlagBitsKHR::eSeparateReferenceImages; + }; + enum class VideoSessionCreateFlagBitsKHR : VkVideoSessionCreateFlagsKHR { eProtectedContent = VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR }; + using VideoSessionCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags = VideoSessionCreateFlagBitsKHR::eProtectedContent; + }; + enum class VideoCodingControlFlagBitsKHR : VkVideoCodingControlFlagsKHR { eReset = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR, @@ -3193,6 +4318,16 @@ namespace VULKAN_HPP_NAMESPACE eEncodeRateControlLayer = VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR }; + using VideoCodingControlFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodingControlFlagsKHR allFlags = + VideoCodingControlFlagBitsKHR::eReset | VideoCodingControlFlagBitsKHR::eEncodeRateControl | VideoCodingControlFlagBitsKHR::eEncodeRateControlLayer; + }; + enum class QueryResultStatusKHR { eError = VK_QUERY_RESULT_STATUS_ERROR_KHR, @@ -3204,13 +4339,40 @@ namespace VULKAN_HPP_NAMESPACE { }; + using VideoSessionParametersCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionParametersCreateFlagsKHR allFlags = {}; + }; + enum class VideoBeginCodingFlagBitsKHR : VkVideoBeginCodingFlagsKHR { }; + using VideoBeginCodingFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoBeginCodingFlagsKHR allFlags = {}; + }; + enum class VideoEndCodingFlagBitsKHR : VkVideoEndCodingFlagsKHR { }; + + using VideoEndCodingFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEndCodingFlagsKHR allFlags = {}; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -3222,6 +4384,16 @@ namespace VULKAN_HPP_NAMESPACE eDpbAndOutputDistinct = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR }; + using VideoDecodeCapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeCapabilityFlagsKHR allFlags = + VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide | VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct; + }; + enum class VideoDecodeUsageFlagBitsKHR : VkVideoDecodeUsageFlagsKHR { eDefault = VK_VIDEO_DECODE_USAGE_DEFAULT_KHR, @@ -3230,9 +4402,28 @@ namespace VULKAN_HPP_NAMESPACE eStreaming = VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR }; + using VideoDecodeUsageFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeUsageFlagsKHR allFlags = VideoDecodeUsageFlagBitsKHR::eDefault | VideoDecodeUsageFlagBitsKHR::eTranscoding | + VideoDecodeUsageFlagBitsKHR::eOffline | VideoDecodeUsageFlagBitsKHR::eStreaming; + }; + enum class VideoDecodeFlagBitsKHR : VkVideoDecodeFlagsKHR { }; + + using VideoDecodeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeFlagsKHR allFlags = {}; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_EXT_transform_feedback === @@ -3241,6 +4432,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineRasterizationStateStreamCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationStateStreamCreateFlagsEXT allFlags = {}; + }; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_EXT_video_encode_h264 === @@ -3273,6 +4473,28 @@ namespace VULKAN_HPP_NAMESPACE eBFrameInL1List = VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT }; + using VideoEncodeH264CapabilityFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT allFlags = + VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceEnabled | VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceDisabled | + VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane | VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass | + VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists | VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance | + VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset | VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset | + VideoEncodeH264CapabilityFlagBitsEXT::ePicInitQpMinus26 | VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPred | + VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredExplicit | VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredImplicit | + VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPredNoTable | VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 | + VideoEncodeH264CapabilityFlagBitsEXT::eCabac | VideoEncodeH264CapabilityFlagBitsEXT::eCavlc | + VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled | VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled | + VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial | VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred | + VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame | VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount | + VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice | VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType | + VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List; + }; + enum class VideoEncodeH264InputModeFlagBitsEXT : VkVideoEncodeH264InputModeFlagsEXT { eFrame = VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT, @@ -3280,6 +4502,16 @@ namespace VULKAN_HPP_NAMESPACE eNonVcl = VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT }; + using VideoEncodeH264InputModeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264InputModeFlagsEXT allFlags = + VideoEncodeH264InputModeFlagBitsEXT::eFrame | VideoEncodeH264InputModeFlagBitsEXT::eSlice | VideoEncodeH264InputModeFlagBitsEXT::eNonVcl; + }; + enum class VideoEncodeH264OutputModeFlagBitsEXT : VkVideoEncodeH264OutputModeFlagsEXT { eFrame = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT, @@ -3287,6 +4519,16 @@ namespace VULKAN_HPP_NAMESPACE eNonVcl = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT }; + using VideoEncodeH264OutputModeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264OutputModeFlagsEXT allFlags = + VideoEncodeH264OutputModeFlagBitsEXT::eFrame | VideoEncodeH264OutputModeFlagBitsEXT::eSlice | VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl; + }; + enum class VideoEncodeH264RateControlStructureEXT { eUnknown = VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT, @@ -3328,6 +4570,28 @@ namespace VULKAN_HPP_NAMESPACE eBFrameInL1List = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT }; + using VideoEncodeH265CapabilityFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CapabilityFlagsEXT allFlags = + VideoEncodeH265CapabilityFlagBitsEXT::eSeparateColourPlane | VideoEncodeH265CapabilityFlagBitsEXT::eScalingLists | + VideoEncodeH265CapabilityFlagBitsEXT::eSampleAdaptiveOffsetEnabled | VideoEncodeH265CapabilityFlagBitsEXT::ePcmEnable | + VideoEncodeH265CapabilityFlagBitsEXT::eSpsTemporalMvpEnabled | VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance | + VideoEncodeH265CapabilityFlagBitsEXT::eInitQpMinus26 | VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2 | + VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled | VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled | + VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipDisabled | VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent | + VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred | VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred | + VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPredNoTable | VideoEncodeH265CapabilityFlagBitsEXT::eTransquantBypassEnabled | + VideoEncodeH265CapabilityFlagBitsEXT::eEntropyCodingSyncEnabled | VideoEncodeH265CapabilityFlagBitsEXT::eDeblockingFilterOverrideEnabled | + VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerFrame | VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSlicePerTile | + VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerSlice | VideoEncodeH265CapabilityFlagBitsEXT::eSliceSegmentCtbCount | + VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment | VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment | + VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType | VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List; + }; + enum class VideoEncodeH265InputModeFlagBitsEXT : VkVideoEncodeH265InputModeFlagsEXT { eFrame = VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT, @@ -3335,6 +4599,16 @@ namespace VULKAN_HPP_NAMESPACE eNonVcl = VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT }; + using VideoEncodeH265InputModeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265InputModeFlagsEXT allFlags = + VideoEncodeH265InputModeFlagBitsEXT::eFrame | VideoEncodeH265InputModeFlagBitsEXT::eSliceSegment | VideoEncodeH265InputModeFlagBitsEXT::eNonVcl; + }; + enum class VideoEncodeH265OutputModeFlagBitsEXT : VkVideoEncodeH265OutputModeFlagsEXT { eFrame = VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT, @@ -3342,6 +4616,16 @@ namespace VULKAN_HPP_NAMESPACE eNonVcl = VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT }; + using VideoEncodeH265OutputModeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265OutputModeFlagsEXT allFlags = + VideoEncodeH265OutputModeFlagBitsEXT::eFrame | VideoEncodeH265OutputModeFlagBitsEXT::eSliceSegment | VideoEncodeH265OutputModeFlagBitsEXT::eNonVcl; + }; + enum class VideoEncodeH265CtbSizeFlagBitsEXT : VkVideoEncodeH265CtbSizeFlagsEXT { e16 = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT, @@ -3349,6 +4633,16 @@ namespace VULKAN_HPP_NAMESPACE e64 = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT }; + using VideoEncodeH265CtbSizeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CtbSizeFlagsEXT allFlags = + VideoEncodeH265CtbSizeFlagBitsEXT::e16 | VideoEncodeH265CtbSizeFlagBitsEXT::e32 | VideoEncodeH265CtbSizeFlagBitsEXT::e64; + }; + enum class VideoEncodeH265TransformBlockSizeFlagBitsEXT : VkVideoEncodeH265TransformBlockSizeFlagsEXT { e4 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT, @@ -3357,6 +4651,17 @@ namespace VULKAN_HPP_NAMESPACE e32 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT }; + using VideoEncodeH265TransformBlockSizeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265TransformBlockSizeFlagsEXT allFlags = + VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4 | VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8 | VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16 | + VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32; + }; + enum class VideoEncodeH265RateControlStructureEXT { eUnknown = VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT, @@ -3374,6 +4679,17 @@ namespace VULKAN_HPP_NAMESPACE eInterlacedInterleavedLines = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT, eInterlacedSeparatePlanes = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT }; + + using VideoDecodeH264PictureLayoutFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT allFlags = VideoDecodeH264PictureLayoutFlagBitsEXT::eProgressive | + VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines | + VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_AMD_shader_info === @@ -3391,6 +4707,15 @@ namespace VULKAN_HPP_NAMESPACE enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkStreamDescriptorSurfaceCreateFlagsGGP { }; + + using StreamDescriptorSurfaceCreateFlagsGGP = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StreamDescriptorSurfaceCreateFlagsGGP allFlags = {}; + }; #endif /*VK_USE_PLATFORM_GGP*/ //=== VK_NV_external_memory_capabilities === @@ -3403,6 +4728,17 @@ namespace VULKAN_HPP_NAMESPACE eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV }; + using ExternalMemoryHandleTypeFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlagsNV allFlags = + ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 | ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt | ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image | + ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt; + }; + enum class ExternalMemoryFeatureFlagBitsNV : VkExternalMemoryFeatureFlagsNV { eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, @@ -3410,6 +4746,16 @@ namespace VULKAN_HPP_NAMESPACE eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV }; + using ExternalMemoryFeatureFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlagsNV allFlags = + ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly | ExternalMemoryFeatureFlagBitsNV::eExportable | ExternalMemoryFeatureFlagBitsNV::eImportable; + }; + //=== VK_EXT_validation_flags === enum class ValidationCheckEXT @@ -3424,6 +4770,15 @@ namespace VULKAN_HPP_NAMESPACE enum class ViSurfaceCreateFlagBitsNN : VkViSurfaceCreateFlagsNN { }; + + using ViSurfaceCreateFlagsNN = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ViSurfaceCreateFlagsNN allFlags = {}; + }; #endif /*VK_USE_PLATFORM_VI_NN*/ //=== VK_EXT_pipeline_robustness === @@ -3451,6 +4806,15 @@ namespace VULKAN_HPP_NAMESPACE eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT }; + using ConditionalRenderingFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ConditionalRenderingFlagsEXT allFlags = ConditionalRenderingFlagBitsEXT::eInverted; + }; + //=== VK_EXT_display_surface_counter === enum class SurfaceCounterFlagBitsEXT : VkSurfaceCounterFlagsEXT @@ -3458,6 +4822,15 @@ namespace VULKAN_HPP_NAMESPACE eVblank = VK_SURFACE_COUNTER_VBLANK_BIT_EXT }; + using SurfaceCounterFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceCounterFlagsEXT allFlags = SurfaceCounterFlagBitsEXT::eVblank; + }; + //=== VK_EXT_display_control === enum class DisplayPowerStateEXT @@ -3495,6 +4868,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineViewportSwizzleStateCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineViewportSwizzleStateCreateFlagsNV allFlags = {}; + }; + //=== VK_EXT_discard_rectangles === enum class DiscardRectangleModeEXT @@ -3507,6 +4889,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDiscardRectangleStateCreateFlagsEXT allFlags = {}; + }; + //=== VK_EXT_conservative_rasterization === enum class ConservativeRasterizationModeEXT @@ -3520,12 +4911,30 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationConservativeStateCreateFlagsEXT allFlags = {}; + }; + //=== VK_EXT_depth_clip_enable === enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkPipelineRasterizationDepthClipStateCreateFlagsEXT { }; + using PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationDepthClipStateCreateFlagsEXT allFlags = {}; + }; + //=== VK_KHR_performance_query === enum class PerformanceCounterDescriptionFlagBitsKHR : VkPerformanceCounterDescriptionFlagsKHR @@ -3534,6 +4943,16 @@ namespace VULKAN_HPP_NAMESPACE eConcurrentlyImpacted = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR }; + using PerformanceCounterDescriptionFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsKHR allFlags = + PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting | PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted; + }; + enum class PerformanceCounterScopeKHR { eCommandBuffer = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, @@ -3573,12 +4992,30 @@ namespace VULKAN_HPP_NAMESPACE { }; + using AcquireProfilingLockFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AcquireProfilingLockFlagsKHR allFlags = {}; + }; + #if defined( VK_USE_PLATFORM_IOS_MVK ) //=== VK_MVK_ios_surface === enum class IOSSurfaceCreateFlagBitsMVK : VkIOSSurfaceCreateFlagsMVK { }; + + using IOSSurfaceCreateFlagsMVK = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR IOSSurfaceCreateFlagsMVK allFlags = {}; + }; #endif /*VK_USE_PLATFORM_IOS_MVK*/ #if defined( VK_USE_PLATFORM_MACOS_MVK ) @@ -3587,6 +5024,15 @@ namespace VULKAN_HPP_NAMESPACE enum class MacOSSurfaceCreateFlagBitsMVK : VkMacOSSurfaceCreateFlagsMVK { }; + + using MacOSSurfaceCreateFlagsMVK = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MacOSSurfaceCreateFlagsMVK allFlags = {}; + }; #endif /*VK_USE_PLATFORM_MACOS_MVK*/ //=== VK_EXT_debug_utils === @@ -3599,6 +5045,17 @@ namespace VULKAN_HPP_NAMESPACE eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT }; + using DebugUtilsMessageSeverityFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT allFlags = + DebugUtilsMessageSeverityFlagBitsEXT::eVerbose | DebugUtilsMessageSeverityFlagBitsEXT::eInfo | DebugUtilsMessageSeverityFlagBitsEXT::eWarning | + DebugUtilsMessageSeverityFlagBitsEXT::eError; + }; + enum class DebugUtilsMessageTypeFlagBitsEXT : VkDebugUtilsMessageTypeFlagsEXT { eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, @@ -3607,14 +5064,43 @@ namespace VULKAN_HPP_NAMESPACE eDeviceAddressBinding = VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT }; + using DebugUtilsMessageTypeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageTypeFlagsEXT allFlags = + DebugUtilsMessageTypeFlagBitsEXT::eGeneral | DebugUtilsMessageTypeFlagBitsEXT::eValidation | DebugUtilsMessageTypeFlagBitsEXT::ePerformance | + DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding; + }; + enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkDebugUtilsMessengerCallbackDataFlagsEXT { }; + using DebugUtilsMessengerCallbackDataFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCallbackDataFlagsEXT allFlags = {}; + }; + enum class DebugUtilsMessengerCreateFlagBitsEXT : VkDebugUtilsMessengerCreateFlagsEXT { }; + using DebugUtilsMessengerCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCreateFlagsEXT allFlags = {}; + }; + //=== VK_EXT_blend_operation_advanced === enum class BlendOverlapEXT @@ -3630,6 +5116,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineCoverageToColorStateCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageToColorStateCreateFlagsNV allFlags = {}; + }; + //=== VK_KHR_acceleration_structure === enum class AccelerationStructureTypeKHR @@ -3654,6 +5149,16 @@ namespace VULKAN_HPP_NAMESPACE }; using GeometryFlagBitsNV = GeometryFlagBitsKHR; + using GeometryFlagsKHR = Flags; + using GeometryFlagsNV = GeometryFlagsKHR; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryFlagsKHR allFlags = GeometryFlagBitsKHR::eOpaque | GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation; + }; + enum class GeometryInstanceFlagBitsKHR : VkGeometryInstanceFlagsKHR { eTriangleFacingCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, @@ -3668,6 +5173,19 @@ namespace VULKAN_HPP_NAMESPACE }; using GeometryInstanceFlagBitsNV = GeometryInstanceFlagBitsKHR; + using GeometryInstanceFlagsKHR = Flags; + using GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryInstanceFlagsKHR allFlags = + GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable | GeometryInstanceFlagBitsKHR::eTriangleFlipFacing | GeometryInstanceFlagBitsKHR::eForceOpaque | + GeometryInstanceFlagBitsKHR::eForceNoOpaque | GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT | + GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT; + }; + enum class BuildAccelerationStructureFlagBitsKHR : VkBuildAccelerationStructureFlagsKHR { eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, @@ -3682,6 +5200,21 @@ namespace VULKAN_HPP_NAMESPACE }; using BuildAccelerationStructureFlagBitsNV = BuildAccelerationStructureFlagBitsKHR; + using BuildAccelerationStructureFlagsKHR = Flags; + using BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BuildAccelerationStructureFlagsKHR allFlags = + BuildAccelerationStructureFlagBitsKHR::eAllowUpdate | BuildAccelerationStructureFlagBitsKHR::eAllowCompaction | + BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace | BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild | + BuildAccelerationStructureFlagBitsKHR::eLowMemory | BuildAccelerationStructureFlagBitsKHR::eMotionNV | + BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT | BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT | + BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT; + }; + enum class CopyAccelerationStructureModeKHR { eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, @@ -3711,6 +5244,16 @@ namespace VULKAN_HPP_NAMESPACE eMotionNV = VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV }; + using AccelerationStructureCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureCreateFlagsKHR allFlags = + AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay | AccelerationStructureCreateFlagBitsKHR::eMotionNV; + }; + enum class BuildAccelerationStructureModeKHR { eBuild = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR, @@ -3731,6 +5274,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineCoverageModulationStateCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageModulationStateCreateFlagsNV allFlags = {}; + }; + //=== VK_EXT_validation_cache === enum class ValidationCacheHeaderVersionEXT @@ -3742,6 +5294,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using ValidationCacheCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ValidationCacheCreateFlagsEXT allFlags = {}; + }; + //=== VK_NV_shading_rate_image === enum class ShadingRatePaletteEntryNV @@ -3783,6 +5344,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineCompilerControlFlagsAMD = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCompilerControlFlagsAMD allFlags = {}; + }; + //=== VK_EXT_calibrated_timestamps === enum class TimeDomainEXT @@ -3852,6 +5422,15 @@ namespace VULKAN_HPP_NAMESPACE enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkImagePipeSurfaceCreateFlagsFUCHSIA { }; + + using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImagePipeSurfaceCreateFlagsFUCHSIA allFlags = {}; + }; #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_METAL_EXT ) @@ -3860,6 +5439,15 @@ namespace VULKAN_HPP_NAMESPACE enum class MetalSurfaceCreateFlagBitsEXT : VkMetalSurfaceCreateFlagsEXT { }; + + using MetalSurfaceCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MetalSurfaceCreateFlagsEXT allFlags = {}; + }; #endif /*VK_USE_PLATFORM_METAL_EXT*/ //=== VK_KHR_fragment_shading_rate === @@ -3879,6 +5467,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using ShaderCorePropertiesFlagsAMD = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderCorePropertiesFlagsAMD allFlags = {}; + }; + //=== VK_EXT_validation_features === enum class ValidationFeatureEnableEXT @@ -3939,6 +5536,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using PipelineCoverageReductionStateCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageReductionStateCreateFlagsNV allFlags = {}; + }; + //=== VK_EXT_provoking_vertex === enum class ProvokingVertexModeEXT @@ -3965,6 +5571,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using HeadlessSurfaceCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR HeadlessSurfaceCreateFlagsEXT allFlags = {}; + }; + //=== VK_EXT_line_rasterization === enum class LineRasterizationModeEXT @@ -3992,6 +5607,15 @@ namespace VULKAN_HPP_NAMESPACE eFlagFrontface = VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV }; + using IndirectStateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectStateFlagsNV allFlags = IndirectStateFlagBitsNV::eFlagFrontface; + }; + enum class IndirectCommandsTokenTypeNV { eShaderGroup = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV, @@ -4012,6 +5636,17 @@ namespace VULKAN_HPP_NAMESPACE eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV }; + using IndirectCommandsLayoutUsageFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV allFlags = IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess | + IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences | + IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences; + }; + //=== VK_EXT_device_memory_report === enum class DeviceMemoryReportEventTypeEXT @@ -4027,6 +5662,15 @@ namespace VULKAN_HPP_NAMESPACE { }; + using DeviceMemoryReportFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceMemoryReportFlagsEXT allFlags = {}; + }; + //=== VK_EXT_pipeline_creation_cache_control === enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags @@ -4035,6 +5679,15 @@ namespace VULKAN_HPP_NAMESPACE eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT }; + using PipelineCacheCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = PipelineCacheCreateFlagBits::eExternallySynchronized; + }; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === @@ -4043,6 +5696,15 @@ namespace VULKAN_HPP_NAMESPACE ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR }; + using VideoEncodeCapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeCapabilityFlagsKHR allFlags = VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes; + }; + enum class VideoEncodeUsageFlagBitsKHR : VkVideoEncodeUsageFlagsKHR { eDefault = VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR, @@ -4052,6 +5714,17 @@ namespace VULKAN_HPP_NAMESPACE eConferencing = VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR }; + using VideoEncodeUsageFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeUsageFlagsKHR allFlags = VideoEncodeUsageFlagBitsKHR::eDefault | VideoEncodeUsageFlagBitsKHR::eTranscoding | + VideoEncodeUsageFlagBitsKHR::eStreaming | VideoEncodeUsageFlagBitsKHR::eRecording | + VideoEncodeUsageFlagBitsKHR::eConferencing; + }; + enum class VideoEncodeContentFlagBitsKHR : VkVideoEncodeContentFlagsKHR { eDefault = VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR, @@ -4060,6 +5733,17 @@ namespace VULKAN_HPP_NAMESPACE eRendered = VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR }; + using VideoEncodeContentFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeContentFlagsKHR allFlags = + VideoEncodeContentFlagBitsKHR::eDefault | VideoEncodeContentFlagBitsKHR::eCamera | VideoEncodeContentFlagBitsKHR::eDesktop | + VideoEncodeContentFlagBitsKHR::eRendered; + }; + enum class VideoEncodeTuningModeKHR { eDefault = VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR, @@ -4076,13 +5760,41 @@ namespace VULKAN_HPP_NAMESPACE eVbr = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR }; + using VideoEncodeRateControlModeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRateControlModeFlagsKHR allFlags = + VideoEncodeRateControlModeFlagBitsKHR::eNone | VideoEncodeRateControlModeFlagBitsKHR::eCbr | VideoEncodeRateControlModeFlagBitsKHR::eVbr; + }; + enum class VideoEncodeFlagBitsKHR : VkVideoEncodeFlagsKHR { }; + using VideoEncodeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFlagsKHR allFlags = {}; + }; + enum class VideoEncodeRateControlFlagBitsKHR : VkVideoEncodeRateControlFlagsKHR { }; + + using VideoEncodeRateControlFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRateControlFlagsKHR allFlags = {}; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_NV_device_diagnostics_config === @@ -4095,6 +5807,17 @@ namespace VULKAN_HPP_NAMESPACE eEnableShaderErrorReporting = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV }; + using DeviceDiagnosticsConfigFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceDiagnosticsConfigFlagsNV allFlags = + DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo | DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking | + DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints | DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting; + }; + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === @@ -4107,6 +5830,17 @@ namespace VULKAN_HPP_NAMESPACE eMetalIosurface = VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT, eMetalSharedEvent = VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT }; + + using ExportMetalObjectTypeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExportMetalObjectTypeFlagsEXT allFlags = + ExportMetalObjectTypeFlagBitsEXT::eMetalDevice | ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue | ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer | + ExportMetalObjectTypeFlagBitsEXT::eMetalTexture | ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface | ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent; + }; #endif /*VK_USE_PLATFORM_METAL_EXT*/ //=== VK_EXT_graphics_pipeline_library === @@ -4119,11 +5853,31 @@ namespace VULKAN_HPP_NAMESPACE eFragmentOutputInterface = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT }; + using GraphicsPipelineLibraryFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR GraphicsPipelineLibraryFlagsEXT allFlags = + GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface | GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders | + GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader | GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface; + }; + enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags { eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT }; + using PipelineLayoutCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT; + }; + //=== VK_NV_fragment_shading_rate_enums === enum class FragmentShadingRateNV @@ -4161,10 +5915,28 @@ namespace VULKAN_HPP_NAMESPACE { }; + using AccelerationStructureMotionInfoFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureMotionInfoFlagsNV allFlags = {}; + }; + enum class AccelerationStructureMotionInstanceFlagBitsNV : VkAccelerationStructureMotionInstanceFlagsNV { }; + using AccelerationStructureMotionInstanceFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureMotionInstanceFlagsNV allFlags = {}; + }; + //=== VK_EXT_image_compression_control === enum class ImageCompressionFlagBitsEXT : VkImageCompressionFlagsEXT @@ -4175,6 +5947,17 @@ namespace VULKAN_HPP_NAMESPACE eDisabled = VK_IMAGE_COMPRESSION_DISABLED_EXT }; + using ImageCompressionFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCompressionFlagsEXT allFlags = + ImageCompressionFlagBitsEXT::eDefault | ImageCompressionFlagBitsEXT::eFixedRateDefault | ImageCompressionFlagBitsEXT::eFixedRateExplicit | + ImageCompressionFlagBitsEXT::eDisabled; + }; + enum class ImageCompressionFixedRateFlagBitsEXT : VkImageCompressionFixedRateFlagsEXT { eNone = VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT, @@ -4204,6 +5987,24 @@ namespace VULKAN_HPP_NAMESPACE e24Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT }; + using ImageCompressionFixedRateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCompressionFixedRateFlagsEXT allFlags = + ImageCompressionFixedRateFlagBitsEXT::eNone | ImageCompressionFixedRateFlagBitsEXT::e1Bpc | ImageCompressionFixedRateFlagBitsEXT::e2Bpc | + ImageCompressionFixedRateFlagBitsEXT::e3Bpc | ImageCompressionFixedRateFlagBitsEXT::e4Bpc | ImageCompressionFixedRateFlagBitsEXT::e5Bpc | + ImageCompressionFixedRateFlagBitsEXT::e6Bpc | ImageCompressionFixedRateFlagBitsEXT::e7Bpc | ImageCompressionFixedRateFlagBitsEXT::e8Bpc | + ImageCompressionFixedRateFlagBitsEXT::e9Bpc | ImageCompressionFixedRateFlagBitsEXT::e10Bpc | ImageCompressionFixedRateFlagBitsEXT::e11Bpc | + ImageCompressionFixedRateFlagBitsEXT::e12Bpc | ImageCompressionFixedRateFlagBitsEXT::e13Bpc | ImageCompressionFixedRateFlagBitsEXT::e14Bpc | + ImageCompressionFixedRateFlagBitsEXT::e15Bpc | ImageCompressionFixedRateFlagBitsEXT::e16Bpc | ImageCompressionFixedRateFlagBitsEXT::e17Bpc | + ImageCompressionFixedRateFlagBitsEXT::e18Bpc | ImageCompressionFixedRateFlagBitsEXT::e19Bpc | ImageCompressionFixedRateFlagBitsEXT::e20Bpc | + ImageCompressionFixedRateFlagBitsEXT::e21Bpc | ImageCompressionFixedRateFlagBitsEXT::e22Bpc | ImageCompressionFixedRateFlagBitsEXT::e23Bpc | + ImageCompressionFixedRateFlagBitsEXT::e24Bpc; + }; + //=== VK_EXT_device_fault === enum class DeviceFaultAddressTypeEXT @@ -4228,6 +6029,15 @@ namespace VULKAN_HPP_NAMESPACE enum class DirectFBSurfaceCreateFlagBitsEXT : VkDirectFBSurfaceCreateFlagsEXT { }; + + using DirectFBSurfaceCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DirectFBSurfaceCreateFlagsEXT allFlags = {}; + }; #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ //=== VK_KHR_ray_tracing_pipeline === @@ -4255,6 +6065,15 @@ namespace VULKAN_HPP_NAMESPACE eInternalObject = VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT }; + using DeviceAddressBindingFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceAddressBindingFlagsEXT allFlags = DeviceAddressBindingFlagBitsEXT::eInternalObject; + }; + enum class DeviceAddressBindingTypeEXT { eBind = VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT, @@ -4273,9 +6092,30 @@ namespace VULKAN_HPP_NAMESPACE eProtectedOptional = VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA }; + using ImageConstraintsInfoFlagsFUCHSIA = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA allFlags = + ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely | ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften | + ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely | ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften | + ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional; + }; + enum class ImageFormatConstraintsFlagBitsFUCHSIA : VkImageFormatConstraintsFlagsFUCHSIA { }; + + using ImageFormatConstraintsFlagsFUCHSIA = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageFormatConstraintsFlagsFUCHSIA allFlags = {}; + }; #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_SCREEN_QNX ) @@ -4284,6 +6124,15 @@ namespace VULKAN_HPP_NAMESPACE enum class ScreenSurfaceCreateFlagBitsQNX : VkScreenSurfaceCreateFlagsQNX { }; + + using ScreenSurfaceCreateFlagsQNX = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ScreenSurfaceCreateFlagsQNX allFlags = {}; + }; #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ //=== VK_EXT_opacity_micromap === @@ -4300,6 +6149,16 @@ namespace VULKAN_HPP_NAMESPACE eAllowCompaction = VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT }; + using BuildMicromapFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BuildMicromapFlagsEXT allFlags = + BuildMicromapFlagBitsEXT::ePreferFastTrace | BuildMicromapFlagBitsEXT::ePreferFastBuild | BuildMicromapFlagBitsEXT::eAllowCompaction; + }; + enum class CopyMicromapModeEXT { eClone = VK_COPY_MICROMAP_MODE_CLONE_EXT, @@ -4313,6 +6172,15 @@ namespace VULKAN_HPP_NAMESPACE eDeviceAddressCaptureReplay = VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT }; + using MicromapCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MicromapCreateFlagsEXT allFlags = MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay; + }; + enum class BuildMicromapModeEXT { eBuild = VK_BUILD_MICROMAP_MODE_BUILD_EXT @@ -4360,6 +6228,16 @@ namespace VULKAN_HPP_NAMESPACE eRasterizationOrderAttachmentAccessARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM }; + using PipelineColorBlendStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags = + PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT; + }; + enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags { eRasterizationOrderAttachmentDepthAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, @@ -4368,6 +6246,17 @@ namespace VULKAN_HPP_NAMESPACE eRasterizationOrderAttachmentStencilAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM }; + using PipelineDepthStencilStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDepthStencilStateCreateFlags allFlags = + PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT | + PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT; + }; + //=== VK_NV_optical_flow === enum class OpticalFlowUsageFlagBitsNV : VkOpticalFlowUsageFlagsNV @@ -4380,6 +6269,17 @@ namespace VULKAN_HPP_NAMESPACE eGlobalFlow = VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV }; + using OpticalFlowUsageFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowUsageFlagsNV allFlags = OpticalFlowUsageFlagBitsNV::eUnknown | OpticalFlowUsageFlagBitsNV::eInput | + OpticalFlowUsageFlagBitsNV::eOutput | OpticalFlowUsageFlagBitsNV::eHint | + OpticalFlowUsageFlagBitsNV::eCost | OpticalFlowUsageFlagBitsNV::eGlobalFlow; + }; + enum class OpticalFlowGridSizeFlagBitsNV : VkOpticalFlowGridSizeFlagsNV { eUnknown = VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV, @@ -4389,6 +6289,17 @@ namespace VULKAN_HPP_NAMESPACE e8X8 = VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV }; + using OpticalFlowGridSizeFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowGridSizeFlagsNV allFlags = OpticalFlowGridSizeFlagBitsNV::eUnknown | OpticalFlowGridSizeFlagBitsNV::e1X1 | + OpticalFlowGridSizeFlagBitsNV::e2X2 | OpticalFlowGridSizeFlagBitsNV::e4X4 | + OpticalFlowGridSizeFlagBitsNV::e8X8; + }; + enum class OpticalFlowPerformanceLevelNV { eUnknown = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV, @@ -4419,11 +6330,36 @@ namespace VULKAN_HPP_NAMESPACE eBothDirections = VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV }; + using OpticalFlowSessionCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowSessionCreateFlagsNV allFlags = + OpticalFlowSessionCreateFlagBitsNV::eEnableHint | OpticalFlowSessionCreateFlagBitsNV::eEnableCost | + OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow | OpticalFlowSessionCreateFlagBitsNV::eAllowRegions | + OpticalFlowSessionCreateFlagBitsNV::eBothDirections; + }; + enum class OpticalFlowExecuteFlagBitsNV : VkOpticalFlowExecuteFlagsNV { eDisableTemporalHints = VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV }; + using OpticalFlowExecuteFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowExecuteFlagsNV allFlags = OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints; + }; + + //========================= + //=== Index Type Traits === + //========================= + template struct IndexTypeValue { @@ -4465,2624 +6401,5 @@ namespace VULKAN_HPP_NAMESPACE using Type = uint8_t; }; - //================ - //=== BITMASKs === - //================ - - //=== VK_VERSION_1_0 === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = - VkFlags( FormatFeatureFlagBits::eSampledImage ) | VkFlags( FormatFeatureFlagBits::eStorageImage ) | - VkFlags( FormatFeatureFlagBits::eStorageImageAtomic ) | VkFlags( FormatFeatureFlagBits::eUniformTexelBuffer ) | - VkFlags( FormatFeatureFlagBits::eStorageTexelBuffer ) | VkFlags( FormatFeatureFlagBits::eStorageTexelBufferAtomic ) | - VkFlags( FormatFeatureFlagBits::eVertexBuffer ) | VkFlags( FormatFeatureFlagBits::eColorAttachment ) | - VkFlags( FormatFeatureFlagBits::eColorAttachmentBlend ) | VkFlags( FormatFeatureFlagBits::eDepthStencilAttachment ) | - VkFlags( FormatFeatureFlagBits::eBlitSrc ) | VkFlags( FormatFeatureFlagBits::eBlitDst ) | VkFlags( FormatFeatureFlagBits::eSampledImageFilterLinear ) | - VkFlags( FormatFeatureFlagBits::eTransferSrc ) | VkFlags( FormatFeatureFlagBits::eTransferDst ) | - VkFlags( FormatFeatureFlagBits::eMidpointChromaSamples ) | VkFlags( FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter ) | - VkFlags( FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter ) | - VkFlags( FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit ) | - VkFlags( FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) | VkFlags( FormatFeatureFlagBits::eDisjoint ) | - VkFlags( FormatFeatureFlagBits::eCositedChromaSamples ) | VkFlags( FormatFeatureFlagBits::eSampledImageFilterMinmax ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( FormatFeatureFlagBits::eVideoDecodeOutputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoDecodeDpbKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR ) | VkFlags( FormatFeatureFlagBits::eSampledImageFilterCubicEXT ) | - VkFlags( FormatFeatureFlagBits::eFragmentDensityMapEXT ) | VkFlags( FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( FormatFeatureFlagBits::eVideoEncodeInputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoEncodeDpbKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - }; - }; - using FormatFeatureFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ImageCreateFlagBits::eSparseBinding ) | VkFlags( ImageCreateFlagBits::eSparseResidency ) | - VkFlags( ImageCreateFlagBits::eSparseAliased ) | VkFlags( ImageCreateFlagBits::eMutableFormat ) | - VkFlags( ImageCreateFlagBits::eCubeCompatible ) | VkFlags( ImageCreateFlagBits::eAlias ) | - VkFlags( ImageCreateFlagBits::eSplitInstanceBindRegions ) | VkFlags( ImageCreateFlagBits::e2DArrayCompatible ) | - VkFlags( ImageCreateFlagBits::eBlockTexelViewCompatible ) | VkFlags( ImageCreateFlagBits::eExtendedUsage ) | - VkFlags( ImageCreateFlagBits::eProtected ) | VkFlags( ImageCreateFlagBits::eDisjoint ) | VkFlags( ImageCreateFlagBits::eCornerSampledNV ) | - VkFlags( ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) | VkFlags( ImageCreateFlagBits::eSubsampledEXT ) | - VkFlags( ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT ) | VkFlags( ImageCreateFlagBits::e2DViewCompatibleEXT ) | - VkFlags( ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM ) - }; - }; - using ImageCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ImageUsageFlagBits::eTransferSrc ) | VkFlags( ImageUsageFlagBits::eTransferDst ) | VkFlags( ImageUsageFlagBits::eSampled ) | - VkFlags( ImageUsageFlagBits::eStorage ) | VkFlags( ImageUsageFlagBits::eColorAttachment ) | - VkFlags( ImageUsageFlagBits::eDepthStencilAttachment ) | VkFlags( ImageUsageFlagBits::eTransientAttachment ) | - VkFlags( ImageUsageFlagBits::eInputAttachment ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( ImageUsageFlagBits::eVideoDecodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoDecodeSrcKHR ) | - VkFlags( ImageUsageFlagBits::eVideoDecodeDpbKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( ImageUsageFlagBits::eFragmentDensityMapEXT ) | VkFlags( ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( ImageUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoEncodeSrcKHR ) | - VkFlags( ImageUsageFlagBits::eVideoEncodeDpbKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( ImageUsageFlagBits::eAttachmentFeedbackLoopEXT ) | VkFlags( ImageUsageFlagBits::eInvocationMaskHUAWEI ) | - VkFlags( ImageUsageFlagBits::eSampleWeightQCOM ) | VkFlags( ImageUsageFlagBits::eSampleBlockMatchQCOM ) - }; - }; - using ImageUsageFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( InstanceCreateFlagBits::eEnumeratePortabilityKHR ) - }; - }; - using InstanceCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( MemoryHeapFlagBits::eDeviceLocal ) | VkFlags( MemoryHeapFlagBits::eMultiInstance ) - }; - }; - using MemoryHeapFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( MemoryPropertyFlagBits::eDeviceLocal ) | VkFlags( MemoryPropertyFlagBits::eHostVisible ) | - VkFlags( MemoryPropertyFlagBits::eHostCoherent ) | VkFlags( MemoryPropertyFlagBits::eHostCached ) | - VkFlags( MemoryPropertyFlagBits::eLazilyAllocated ) | VkFlags( MemoryPropertyFlagBits::eProtected ) | - VkFlags( MemoryPropertyFlagBits::eDeviceCoherentAMD ) | VkFlags( MemoryPropertyFlagBits::eDeviceUncachedAMD ) | - VkFlags( MemoryPropertyFlagBits::eRdmaCapableNV ) - }; - }; - using MemoryPropertyFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( QueueFlagBits::eGraphics ) | VkFlags( QueueFlagBits::eCompute ) | VkFlags( QueueFlagBits::eTransfer ) | - VkFlags( QueueFlagBits::eSparseBinding ) | VkFlags( QueueFlagBits::eProtected ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( QueueFlagBits::eVideoDecodeKHR ) | VkFlags( QueueFlagBits::eVideoEncodeKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( QueueFlagBits::eOpticalFlowNV ) - }; - }; - using QueueFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SampleCountFlagBits::e1 ) | VkFlags( SampleCountFlagBits::e2 ) | VkFlags( SampleCountFlagBits::e4 ) | - VkFlags( SampleCountFlagBits::e8 ) | VkFlags( SampleCountFlagBits::e16 ) | VkFlags( SampleCountFlagBits::e32 ) | - VkFlags( SampleCountFlagBits::e64 ) - }; - }; - using SampleCountFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DeviceCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DeviceQueueCreateFlagBits::eProtected ) - }; - }; - using DeviceQueueCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PipelineStageFlagBits::eTopOfPipe ) | VkFlags( PipelineStageFlagBits::eDrawIndirect ) | - VkFlags( PipelineStageFlagBits::eVertexInput ) | VkFlags( PipelineStageFlagBits::eVertexShader ) | - VkFlags( PipelineStageFlagBits::eTessellationControlShader ) | VkFlags( PipelineStageFlagBits::eTessellationEvaluationShader ) | - VkFlags( PipelineStageFlagBits::eGeometryShader ) | VkFlags( PipelineStageFlagBits::eFragmentShader ) | - VkFlags( PipelineStageFlagBits::eEarlyFragmentTests ) | VkFlags( PipelineStageFlagBits::eLateFragmentTests ) | - VkFlags( PipelineStageFlagBits::eColorAttachmentOutput ) | VkFlags( PipelineStageFlagBits::eComputeShader ) | - VkFlags( PipelineStageFlagBits::eTransfer ) | VkFlags( PipelineStageFlagBits::eBottomOfPipe ) | VkFlags( PipelineStageFlagBits::eHost ) | - VkFlags( PipelineStageFlagBits::eAllGraphics ) | VkFlags( PipelineStageFlagBits::eAllCommands ) | VkFlags( PipelineStageFlagBits::eNone ) | - VkFlags( PipelineStageFlagBits::eTransformFeedbackEXT ) | VkFlags( PipelineStageFlagBits::eConditionalRenderingEXT ) | - VkFlags( PipelineStageFlagBits::eAccelerationStructureBuildKHR ) | VkFlags( PipelineStageFlagBits::eRayTracingShaderKHR ) | - VkFlags( PipelineStageFlagBits::eFragmentDensityProcessEXT ) | VkFlags( PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR ) | - VkFlags( PipelineStageFlagBits::eCommandPreprocessNV ) | VkFlags( PipelineStageFlagBits::eTaskShaderEXT ) | - VkFlags( PipelineStageFlagBits::eMeshShaderEXT ) - }; - }; - using PipelineStageFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using MemoryMapFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ImageAspectFlagBits::eColor ) | VkFlags( ImageAspectFlagBits::eDepth ) | VkFlags( ImageAspectFlagBits::eStencil ) | - VkFlags( ImageAspectFlagBits::eMetadata ) | VkFlags( ImageAspectFlagBits::ePlane0 ) | VkFlags( ImageAspectFlagBits::ePlane1 ) | - VkFlags( ImageAspectFlagBits::ePlane2 ) | VkFlags( ImageAspectFlagBits::eNone ) | VkFlags( ImageAspectFlagBits::eMemoryPlane0EXT ) | - VkFlags( ImageAspectFlagBits::eMemoryPlane1EXT ) | VkFlags( ImageAspectFlagBits::eMemoryPlane2EXT ) | - VkFlags( ImageAspectFlagBits::eMemoryPlane3EXT ) - }; - }; - using ImageAspectFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SparseImageFormatFlagBits::eSingleMiptail ) | VkFlags( SparseImageFormatFlagBits::eAlignedMipSize ) | - VkFlags( SparseImageFormatFlagBits::eNonstandardBlockSize ) - }; - }; - using SparseImageFormatFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SparseMemoryBindFlagBits::eMetadata ) - }; - }; - using SparseMemoryBindFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( FenceCreateFlagBits::eSignaled ) - }; - }; - using FenceCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using SemaphoreCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( EventCreateFlagBits::eDeviceOnly ) - }; - }; - using EventCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( QueryPipelineStatisticFlagBits::eInputAssemblyVertices ) | VkFlags( QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives ) | - VkFlags( QueryPipelineStatisticFlagBits::eVertexShaderInvocations ) | VkFlags( QueryPipelineStatisticFlagBits::eGeometryShaderInvocations ) | - VkFlags( QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives ) | VkFlags( QueryPipelineStatisticFlagBits::eClippingInvocations ) | - VkFlags( QueryPipelineStatisticFlagBits::eClippingPrimitives ) | VkFlags( QueryPipelineStatisticFlagBits::eFragmentShaderInvocations ) | - VkFlags( QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches ) | - VkFlags( QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations ) | - VkFlags( QueryPipelineStatisticFlagBits::eComputeShaderInvocations ) | VkFlags( QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT ) | - VkFlags( QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT ) - }; - }; - using QueryPipelineStatisticFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using QueryPoolCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( QueryResultFlagBits::e64 ) | VkFlags( QueryResultFlagBits::eWait ) | VkFlags( QueryResultFlagBits::eWithAvailability ) | - VkFlags( QueryResultFlagBits::ePartial ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( QueryResultFlagBits::eWithStatusKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - }; - }; - using QueryResultFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( BufferCreateFlagBits::eSparseBinding ) | VkFlags( BufferCreateFlagBits::eSparseResidency ) | - VkFlags( BufferCreateFlagBits::eSparseAliased ) | VkFlags( BufferCreateFlagBits::eProtected ) | - VkFlags( BufferCreateFlagBits::eDeviceAddressCaptureReplay ) - }; - }; - using BufferCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( BufferUsageFlagBits::eTransferSrc ) | VkFlags( BufferUsageFlagBits::eTransferDst ) | - VkFlags( BufferUsageFlagBits::eUniformTexelBuffer ) | VkFlags( BufferUsageFlagBits::eStorageTexelBuffer ) | - VkFlags( BufferUsageFlagBits::eUniformBuffer ) | VkFlags( BufferUsageFlagBits::eStorageBuffer ) | - VkFlags( BufferUsageFlagBits::eIndexBuffer ) | VkFlags( BufferUsageFlagBits::eVertexBuffer ) | - VkFlags( BufferUsageFlagBits::eIndirectBuffer ) | VkFlags( BufferUsageFlagBits::eShaderDeviceAddress ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( BufferUsageFlagBits::eVideoDecodeSrcKHR ) | VkFlags( BufferUsageFlagBits::eVideoDecodeDstKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( BufferUsageFlagBits::eTransformFeedbackBufferEXT ) | VkFlags( BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) | - VkFlags( BufferUsageFlagBits::eConditionalRenderingEXT ) | VkFlags( BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR ) | - VkFlags( BufferUsageFlagBits::eAccelerationStructureStorageKHR ) | VkFlags( BufferUsageFlagBits::eShaderBindingTableKHR ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( BufferUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( BufferUsageFlagBits::eVideoEncodeSrcKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT ) | VkFlags( BufferUsageFlagBits::eMicromapStorageEXT ) - }; - }; - using BufferUsageFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using BufferViewCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT ) | VkFlags( ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT ) - }; - }; - using ImageViewCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using ShaderModuleCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PipelineCacheCreateFlagBits::eExternallySynchronized ) - }; - }; - using PipelineCacheCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ColorComponentFlagBits::eR ) | VkFlags( ColorComponentFlagBits::eG ) | VkFlags( ColorComponentFlagBits::eB ) | - VkFlags( ColorComponentFlagBits::eA ) - }; - }; - using ColorComponentFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( CullModeFlagBits::eNone ) | VkFlags( CullModeFlagBits::eFront ) | VkFlags( CullModeFlagBits::eBack ) | - VkFlags( CullModeFlagBits::eFrontAndBack ) - }; - }; - using CullModeFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT ) - }; - }; - using PipelineColorBlendStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PipelineCreateFlagBits::eDisableOptimization ) | VkFlags( PipelineCreateFlagBits::eAllowDerivatives ) | - VkFlags( PipelineCreateFlagBits::eDerivative ) | VkFlags( PipelineCreateFlagBits::eViewIndexFromDeviceIndex ) | - VkFlags( PipelineCreateFlagBits::eDispatchBase ) | VkFlags( PipelineCreateFlagBits::eFailOnPipelineCompileRequired ) | - VkFlags( PipelineCreateFlagBits::eEarlyReturnOnFailure ) | VkFlags( PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR ) | - VkFlags( PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT ) | - VkFlags( PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR ) | - VkFlags( PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR ) | VkFlags( PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR ) | - VkFlags( PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR ) | VkFlags( PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR ) | - VkFlags( PipelineCreateFlagBits::eRayTracingSkipAabbsKHR ) | VkFlags( PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR ) | - VkFlags( PipelineCreateFlagBits::eDeferCompileNV ) | VkFlags( PipelineCreateFlagBits::eCaptureStatisticsKHR ) | - VkFlags( PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR ) | VkFlags( PipelineCreateFlagBits::eIndirectBindableNV ) | - VkFlags( PipelineCreateFlagBits::eLibraryKHR ) | VkFlags( PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT ) | - VkFlags( PipelineCreateFlagBits::eLinkTimeOptimizationEXT ) | VkFlags( PipelineCreateFlagBits::eRayTracingAllowMotionNV ) | - VkFlags( PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT ) | - VkFlags( PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT ) | VkFlags( PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT ) | - VkFlags( PipelineCreateFlagBits::eNoProtectedAccessEXT ) | VkFlags( PipelineCreateFlagBits::eProtectedAccessOnlyEXT ) - }; - }; - using PipelineCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT ) | - VkFlags( PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT ) - }; - }; - using PipelineDepthStencilStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineDynamicStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineInputAssemblyStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PipelineLayoutCreateFlagBits::eIndependentSetsEXT ) - }; - }; - using PipelineLayoutCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineMultisampleStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineRasterizationStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize ) | VkFlags( PipelineShaderStageCreateFlagBits::eRequireFullSubgroups ) - }; - }; - using PipelineShaderStageCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineTessellationStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineVertexInputStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineViewportStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ShaderStageFlagBits::eVertex ) | VkFlags( ShaderStageFlagBits::eTessellationControl ) | - VkFlags( ShaderStageFlagBits::eTessellationEvaluation ) | VkFlags( ShaderStageFlagBits::eGeometry ) | - VkFlags( ShaderStageFlagBits::eFragment ) | VkFlags( ShaderStageFlagBits::eCompute ) | VkFlags( ShaderStageFlagBits::eAllGraphics ) | - VkFlags( ShaderStageFlagBits::eAll ) | VkFlags( ShaderStageFlagBits::eRaygenKHR ) | VkFlags( ShaderStageFlagBits::eAnyHitKHR ) | - VkFlags( ShaderStageFlagBits::eClosestHitKHR ) | VkFlags( ShaderStageFlagBits::eMissKHR ) | VkFlags( ShaderStageFlagBits::eIntersectionKHR ) | - VkFlags( ShaderStageFlagBits::eCallableKHR ) | VkFlags( ShaderStageFlagBits::eTaskEXT ) | VkFlags( ShaderStageFlagBits::eMeshEXT ) | - VkFlags( ShaderStageFlagBits::eSubpassShadingHUAWEI ) - }; - }; - using ShaderStageFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SamplerCreateFlagBits::eSubsampledEXT ) | VkFlags( SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT ) | - VkFlags( SamplerCreateFlagBits::eNonSeamlessCubeMapEXT ) | VkFlags( SamplerCreateFlagBits::eImageProcessingQCOM ) - }; - }; - using SamplerCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) | VkFlags( DescriptorPoolCreateFlagBits::eUpdateAfterBind ) | - VkFlags( DescriptorPoolCreateFlagBits::eHostOnlyEXT ) - }; - }; - using DescriptorPoolCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DescriptorPoolResetFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool ) | VkFlags( DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR ) | - VkFlags( DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT ) - }; - }; - using DescriptorSetLayoutCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( AccessFlagBits::eIndirectCommandRead ) | VkFlags( AccessFlagBits::eIndexRead ) | VkFlags( AccessFlagBits::eVertexAttributeRead ) | - VkFlags( AccessFlagBits::eUniformRead ) | VkFlags( AccessFlagBits::eInputAttachmentRead ) | VkFlags( AccessFlagBits::eShaderRead ) | - VkFlags( AccessFlagBits::eShaderWrite ) | VkFlags( AccessFlagBits::eColorAttachmentRead ) | VkFlags( AccessFlagBits::eColorAttachmentWrite ) | - VkFlags( AccessFlagBits::eDepthStencilAttachmentRead ) | VkFlags( AccessFlagBits::eDepthStencilAttachmentWrite ) | - VkFlags( AccessFlagBits::eTransferRead ) | VkFlags( AccessFlagBits::eTransferWrite ) | VkFlags( AccessFlagBits::eHostRead ) | - VkFlags( AccessFlagBits::eHostWrite ) | VkFlags( AccessFlagBits::eMemoryRead ) | VkFlags( AccessFlagBits::eMemoryWrite ) | - VkFlags( AccessFlagBits::eNone ) | VkFlags( AccessFlagBits::eTransformFeedbackWriteEXT ) | - VkFlags( AccessFlagBits::eTransformFeedbackCounterReadEXT ) | VkFlags( AccessFlagBits::eTransformFeedbackCounterWriteEXT ) | - VkFlags( AccessFlagBits::eConditionalRenderingReadEXT ) | VkFlags( AccessFlagBits::eColorAttachmentReadNoncoherentEXT ) | - VkFlags( AccessFlagBits::eAccelerationStructureReadKHR ) | VkFlags( AccessFlagBits::eAccelerationStructureWriteKHR ) | - VkFlags( AccessFlagBits::eFragmentDensityMapReadEXT ) | VkFlags( AccessFlagBits::eFragmentShadingRateAttachmentReadKHR ) | - VkFlags( AccessFlagBits::eCommandPreprocessReadNV ) | VkFlags( AccessFlagBits::eCommandPreprocessWriteNV ) - }; - }; - using AccessFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( AttachmentDescriptionFlagBits::eMayAlias ) - }; - }; - using AttachmentDescriptionFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DependencyFlagBits::eByRegion ) | VkFlags( DependencyFlagBits::eDeviceGroup ) | VkFlags( DependencyFlagBits::eViewLocal ) | - VkFlags( DependencyFlagBits::eFeedbackLoopEXT ) - }; - }; - using DependencyFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( FramebufferCreateFlagBits::eImageless ) - }; - }; - using FramebufferCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( RenderPassCreateFlagBits::eTransformQCOM ) - }; - }; - using RenderPassCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SubpassDescriptionFlagBits::ePerViewAttributesNVX ) | VkFlags( SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX ) | - VkFlags( SubpassDescriptionFlagBits::eFragmentRegionQCOM ) | VkFlags( SubpassDescriptionFlagBits::eShaderResolveQCOM ) | - VkFlags( SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT ) | - VkFlags( SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT ) | - VkFlags( SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT ) | - VkFlags( SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT ) - }; - }; - using SubpassDescriptionFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( CommandPoolCreateFlagBits::eTransient ) | VkFlags( CommandPoolCreateFlagBits::eResetCommandBuffer ) | - VkFlags( CommandPoolCreateFlagBits::eProtected ) - }; - }; - using CommandPoolCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( CommandPoolResetFlagBits::eReleaseResources ) - }; - }; - using CommandPoolResetFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( CommandBufferResetFlagBits::eReleaseResources ) - }; - }; - using CommandBufferResetFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( CommandBufferUsageFlagBits::eOneTimeSubmit ) | VkFlags( CommandBufferUsageFlagBits::eRenderPassContinue ) | - VkFlags( CommandBufferUsageFlagBits::eSimultaneousUse ) - }; - }; - using CommandBufferUsageFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( QueryControlFlagBits::ePrecise ) - }; - }; - using QueryControlFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( StencilFaceFlagBits::eFront ) | VkFlags( StencilFaceFlagBits::eBack ) | VkFlags( StencilFaceFlagBits::eFrontAndBack ) - }; - }; - using StencilFaceFlags = Flags; - - //=== VK_VERSION_1_1 === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SubgroupFeatureFlagBits::eBasic ) | VkFlags( SubgroupFeatureFlagBits::eVote ) | VkFlags( SubgroupFeatureFlagBits::eArithmetic ) | - VkFlags( SubgroupFeatureFlagBits::eBallot ) | VkFlags( SubgroupFeatureFlagBits::eShuffle ) | - VkFlags( SubgroupFeatureFlagBits::eShuffleRelative ) | VkFlags( SubgroupFeatureFlagBits::eClustered ) | - VkFlags( SubgroupFeatureFlagBits::eQuad ) | VkFlags( SubgroupFeatureFlagBits::ePartitionedNV ) - }; - }; - using SubgroupFeatureFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PeerMemoryFeatureFlagBits::eCopySrc ) | VkFlags( PeerMemoryFeatureFlagBits::eCopyDst ) | - VkFlags( PeerMemoryFeatureFlagBits::eGenericSrc ) | VkFlags( PeerMemoryFeatureFlagBits::eGenericDst ) - }; - }; - using PeerMemoryFeatureFlags = Flags; - using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( MemoryAllocateFlagBits::eDeviceMask ) | VkFlags( MemoryAllocateFlagBits::eDeviceAddress ) | - VkFlags( MemoryAllocateFlagBits::eDeviceAddressCaptureReplay ) - }; - }; - using MemoryAllocateFlags = Flags; - using MemoryAllocateFlagsKHR = MemoryAllocateFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using CommandPoolTrimFlags = Flags; - using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DescriptorUpdateTemplateCreateFlags = Flags; - using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 ) | - VkFlags( ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D11Texture ) | - VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D12Heap ) | - VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D12Resource ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eDmaBufEXT ) -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - | VkFlags( ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID ) -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) -#if defined( VK_USE_PLATFORM_FUCHSIA ) - | VkFlags( ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA ) -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - | VkFlags( ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV ) - }; - }; - using ExternalMemoryHandleTypeFlags = Flags; - using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExternalMemoryFeatureFlagBits::eDedicatedOnly ) | VkFlags( ExternalMemoryFeatureFlagBits::eExportable ) | - VkFlags( ExternalMemoryFeatureFlagBits::eImportable ) - }; - }; - using ExternalMemoryFeatureFlags = Flags; - using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExternalFenceHandleTypeFlagBits::eOpaqueFd ) | VkFlags( ExternalFenceHandleTypeFlagBits::eOpaqueWin32 ) | - VkFlags( ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt ) | VkFlags( ExternalFenceHandleTypeFlagBits::eSyncFd ) - }; - }; - using ExternalFenceHandleTypeFlags = Flags; - using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExternalFenceFeatureFlagBits::eExportable ) | VkFlags( ExternalFenceFeatureFlagBits::eImportable ) - }; - }; - using ExternalFenceFeatureFlags = Flags; - using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( FenceImportFlagBits::eTemporary ) - }; - }; - using FenceImportFlags = Flags; - using FenceImportFlagsKHR = FenceImportFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SemaphoreImportFlagBits::eTemporary ) - }; - }; - using SemaphoreImportFlags = Flags; - using SemaphoreImportFlagsKHR = SemaphoreImportFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 ) | - VkFlags( ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt ) | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence ) | - VkFlags( ExternalSemaphoreHandleTypeFlagBits::eSyncFd ) -#if defined( VK_USE_PLATFORM_FUCHSIA ) - | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA ) -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - }; - }; - using ExternalSemaphoreHandleTypeFlags = Flags; - using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExternalSemaphoreFeatureFlagBits::eExportable ) | VkFlags( ExternalSemaphoreFeatureFlagBits::eImportable ) - }; - }; - using ExternalSemaphoreFeatureFlags = Flags; - using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; - - //=== VK_VERSION_1_2 === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DescriptorBindingFlagBits::eUpdateAfterBind ) | VkFlags( DescriptorBindingFlagBits::eUpdateUnusedWhilePending ) | - VkFlags( DescriptorBindingFlagBits::ePartiallyBound ) | VkFlags( DescriptorBindingFlagBits::eVariableDescriptorCount ) - }; - }; - using DescriptorBindingFlags = Flags; - using DescriptorBindingFlagsEXT = DescriptorBindingFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ResolveModeFlagBits::eNone ) | VkFlags( ResolveModeFlagBits::eSampleZero ) | VkFlags( ResolveModeFlagBits::eAverage ) | - VkFlags( ResolveModeFlagBits::eMin ) | VkFlags( ResolveModeFlagBits::eMax ) - }; - }; - using ResolveModeFlags = Flags; - using ResolveModeFlagsKHR = ResolveModeFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SemaphoreWaitFlagBits::eAny ) - }; - }; - using SemaphoreWaitFlags = Flags; - using SemaphoreWaitFlagsKHR = SemaphoreWaitFlags; - - //=== VK_VERSION_1_3 === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( PipelineCreationFeedbackFlagBits::eValid ) | VkFlags( PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit ) | - VkFlags( PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration ) - }; - }; - using PipelineCreationFeedbackFlags = Flags; - using PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ToolPurposeFlagBits::eValidation ) | VkFlags( ToolPurposeFlagBits::eProfiling ) | VkFlags( ToolPurposeFlagBits::eTracing ) | - VkFlags( ToolPurposeFlagBits::eAdditionalFeatures ) | VkFlags( ToolPurposeFlagBits::eModifyingFeatures ) | - VkFlags( ToolPurposeFlagBits::eDebugReportingEXT ) | VkFlags( ToolPurposeFlagBits::eDebugMarkersEXT ) - }; - }; - using ToolPurposeFlags = Flags; - using ToolPurposeFlagsEXT = ToolPurposeFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PrivateDataSlotCreateFlags = Flags; - using PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags64 - { - allFlags = VkFlags64( PipelineStageFlagBits2::eNone ) | VkFlags64( PipelineStageFlagBits2::eTopOfPipe ) | - VkFlags64( PipelineStageFlagBits2::eDrawIndirect ) | VkFlags64( PipelineStageFlagBits2::eVertexInput ) | - VkFlags64( PipelineStageFlagBits2::eVertexShader ) | VkFlags64( PipelineStageFlagBits2::eTessellationControlShader ) | - VkFlags64( PipelineStageFlagBits2::eTessellationEvaluationShader ) | VkFlags64( PipelineStageFlagBits2::eGeometryShader ) | - VkFlags64( PipelineStageFlagBits2::eFragmentShader ) | VkFlags64( PipelineStageFlagBits2::eEarlyFragmentTests ) | - VkFlags64( PipelineStageFlagBits2::eLateFragmentTests ) | VkFlags64( PipelineStageFlagBits2::eColorAttachmentOutput ) | - VkFlags64( PipelineStageFlagBits2::eComputeShader ) | VkFlags64( PipelineStageFlagBits2::eAllTransfer ) | - VkFlags64( PipelineStageFlagBits2::eBottomOfPipe ) | VkFlags64( PipelineStageFlagBits2::eHost ) | - VkFlags64( PipelineStageFlagBits2::eAllGraphics ) | VkFlags64( PipelineStageFlagBits2::eAllCommands ) | - VkFlags64( PipelineStageFlagBits2::eCopy ) | VkFlags64( PipelineStageFlagBits2::eResolve ) | VkFlags64( PipelineStageFlagBits2::eBlit ) | - VkFlags64( PipelineStageFlagBits2::eClear ) | VkFlags64( PipelineStageFlagBits2::eIndexInput ) | - VkFlags64( PipelineStageFlagBits2::eVertexAttributeInput ) | VkFlags64( PipelineStageFlagBits2::ePreRasterizationShaders ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( PipelineStageFlagBits2::eVideoDecodeKHR ) | VkFlags64( PipelineStageFlagBits2::eVideoEncodeKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( PipelineStageFlagBits2::eTransformFeedbackEXT ) | VkFlags64( PipelineStageFlagBits2::eConditionalRenderingEXT ) | - VkFlags64( PipelineStageFlagBits2::eCommandPreprocessNV ) | VkFlags64( PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR ) | - VkFlags64( PipelineStageFlagBits2::eAccelerationStructureBuildKHR ) | VkFlags64( PipelineStageFlagBits2::eRayTracingShaderKHR ) | - VkFlags64( PipelineStageFlagBits2::eFragmentDensityProcessEXT ) | VkFlags64( PipelineStageFlagBits2::eTaskShaderEXT ) | - VkFlags64( PipelineStageFlagBits2::eMeshShaderEXT ) | VkFlags64( PipelineStageFlagBits2::eSubpassShadingHUAWEI ) | - VkFlags64( PipelineStageFlagBits2::eInvocationMaskHUAWEI ) | VkFlags64( PipelineStageFlagBits2::eAccelerationStructureCopyKHR ) | - VkFlags64( PipelineStageFlagBits2::eMicromapBuildEXT ) | VkFlags64( PipelineStageFlagBits2::eOpticalFlowNV ) - }; - }; - using PipelineStageFlags2 = Flags; - using PipelineStageFlags2KHR = PipelineStageFlags2; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags64 - { - allFlags = - VkFlags64( AccessFlagBits2::eNone ) | VkFlags64( AccessFlagBits2::eIndirectCommandRead ) | VkFlags64( AccessFlagBits2::eIndexRead ) | - VkFlags64( AccessFlagBits2::eVertexAttributeRead ) | VkFlags64( AccessFlagBits2::eUniformRead ) | VkFlags64( AccessFlagBits2::eInputAttachmentRead ) | - VkFlags64( AccessFlagBits2::eShaderRead ) | VkFlags64( AccessFlagBits2::eShaderWrite ) | VkFlags64( AccessFlagBits2::eColorAttachmentRead ) | - VkFlags64( AccessFlagBits2::eColorAttachmentWrite ) | VkFlags64( AccessFlagBits2::eDepthStencilAttachmentRead ) | - VkFlags64( AccessFlagBits2::eDepthStencilAttachmentWrite ) | VkFlags64( AccessFlagBits2::eTransferRead ) | - VkFlags64( AccessFlagBits2::eTransferWrite ) | VkFlags64( AccessFlagBits2::eHostRead ) | VkFlags64( AccessFlagBits2::eHostWrite ) | - VkFlags64( AccessFlagBits2::eMemoryRead ) | VkFlags64( AccessFlagBits2::eMemoryWrite ) | VkFlags64( AccessFlagBits2::eShaderSampledRead ) | - VkFlags64( AccessFlagBits2::eShaderStorageRead ) | VkFlags64( AccessFlagBits2::eShaderStorageWrite ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( AccessFlagBits2::eVideoDecodeReadKHR ) | VkFlags64( AccessFlagBits2::eVideoDecodeWriteKHR ) | - VkFlags64( AccessFlagBits2::eVideoEncodeReadKHR ) | VkFlags64( AccessFlagBits2::eVideoEncodeWriteKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( AccessFlagBits2::eTransformFeedbackWriteEXT ) | VkFlags64( AccessFlagBits2::eTransformFeedbackCounterReadEXT ) | - VkFlags64( AccessFlagBits2::eTransformFeedbackCounterWriteEXT ) | VkFlags64( AccessFlagBits2::eConditionalRenderingReadEXT ) | - VkFlags64( AccessFlagBits2::eCommandPreprocessReadNV ) | VkFlags64( AccessFlagBits2::eCommandPreprocessWriteNV ) | - VkFlags64( AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR ) | VkFlags64( AccessFlagBits2::eAccelerationStructureReadKHR ) | - VkFlags64( AccessFlagBits2::eAccelerationStructureWriteKHR ) | VkFlags64( AccessFlagBits2::eFragmentDensityMapReadEXT ) | - VkFlags64( AccessFlagBits2::eColorAttachmentReadNoncoherentEXT ) | VkFlags64( AccessFlagBits2::eInvocationMaskReadHUAWEI ) | - VkFlags64( AccessFlagBits2::eShaderBindingTableReadKHR ) | VkFlags64( AccessFlagBits2::eMicromapReadEXT ) | - VkFlags64( AccessFlagBits2::eMicromapWriteEXT ) | VkFlags64( AccessFlagBits2::eOpticalFlowReadNV ) | VkFlags64( AccessFlagBits2::eOpticalFlowWriteNV ) - }; - }; - using AccessFlags2 = Flags; - using AccessFlags2KHR = AccessFlags2; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SubmitFlagBits::eProtected ) - }; - }; - using SubmitFlags = Flags; - using SubmitFlagsKHR = SubmitFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( RenderingFlagBits::eContentsSecondaryCommandBuffers ) | VkFlags( RenderingFlagBits::eSuspending ) | - VkFlags( RenderingFlagBits::eResuming ) | VkFlags( RenderingFlagBits::eEnableLegacyDitheringEXT ) - }; - }; - using RenderingFlags = Flags; - using RenderingFlagsKHR = RenderingFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags64 - { - allFlags = VkFlags64( FormatFeatureFlagBits2::eSampledImage ) | VkFlags64( FormatFeatureFlagBits2::eStorageImage ) | - VkFlags64( FormatFeatureFlagBits2::eStorageImageAtomic ) | VkFlags64( FormatFeatureFlagBits2::eUniformTexelBuffer ) | - VkFlags64( FormatFeatureFlagBits2::eStorageTexelBuffer ) | VkFlags64( FormatFeatureFlagBits2::eStorageTexelBufferAtomic ) | - VkFlags64( FormatFeatureFlagBits2::eVertexBuffer ) | VkFlags64( FormatFeatureFlagBits2::eColorAttachment ) | - VkFlags64( FormatFeatureFlagBits2::eColorAttachmentBlend ) | VkFlags64( FormatFeatureFlagBits2::eDepthStencilAttachment ) | - VkFlags64( FormatFeatureFlagBits2::eBlitSrc ) | VkFlags64( FormatFeatureFlagBits2::eBlitDst ) | - VkFlags64( FormatFeatureFlagBits2::eSampledImageFilterLinear ) | VkFlags64( FormatFeatureFlagBits2::eSampledImageFilterCubic ) | - VkFlags64( FormatFeatureFlagBits2::eTransferSrc ) | VkFlags64( FormatFeatureFlagBits2::eTransferDst ) | - VkFlags64( FormatFeatureFlagBits2::eSampledImageFilterMinmax ) | VkFlags64( FormatFeatureFlagBits2::eMidpointChromaSamples ) | - VkFlags64( FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter ) | - VkFlags64( FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter ) | - VkFlags64( FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit ) | - VkFlags64( FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) | - VkFlags64( FormatFeatureFlagBits2::eDisjoint ) | VkFlags64( FormatFeatureFlagBits2::eCositedChromaSamples ) | - VkFlags64( FormatFeatureFlagBits2::eStorageReadWithoutFormat ) | VkFlags64( FormatFeatureFlagBits2::eStorageWriteWithoutFormat ) | - VkFlags64( FormatFeatureFlagBits2::eSampledImageDepthComparison ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeOutputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeDpbKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR ) | VkFlags64( FormatFeatureFlagBits2::eFragmentDensityMapEXT ) | - VkFlags64( FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeInputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( FormatFeatureFlagBits2::eLinearColorAttachmentNV ) | VkFlags64( FormatFeatureFlagBits2::eWeightImageQCOM ) | - VkFlags64( FormatFeatureFlagBits2::eWeightSampledImageQCOM ) | VkFlags64( FormatFeatureFlagBits2::eBlockMatchingQCOM ) | - VkFlags64( FormatFeatureFlagBits2::eBoxFilterSampledQCOM ) | VkFlags64( FormatFeatureFlagBits2::eOpticalFlowImageNV ) | - VkFlags64( FormatFeatureFlagBits2::eOpticalFlowVectorNV ) | VkFlags64( FormatFeatureFlagBits2::eOpticalFlowCostNV ) - }; - }; - using FormatFeatureFlags2 = Flags; - using FormatFeatureFlags2KHR = FormatFeatureFlags2; - - //=== VK_KHR_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( CompositeAlphaFlagBitsKHR::eOpaque ) | VkFlags( CompositeAlphaFlagBitsKHR::ePreMultiplied ) | - VkFlags( CompositeAlphaFlagBitsKHR::ePostMultiplied ) | VkFlags( CompositeAlphaFlagBitsKHR::eInherit ) - }; - }; - using CompositeAlphaFlagsKHR = Flags; - - //=== VK_KHR_swapchain === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions ) | VkFlags( SwapchainCreateFlagBitsKHR::eProtected ) | - VkFlags( SwapchainCreateFlagBitsKHR::eMutableFormat ) - }; - }; - using SwapchainCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DeviceGroupPresentModeFlagBitsKHR::eLocal ) | VkFlags( DeviceGroupPresentModeFlagBitsKHR::eRemote ) | - VkFlags( DeviceGroupPresentModeFlagBitsKHR::eSum ) | VkFlags( DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice ) - }; - }; - using DeviceGroupPresentModeFlagsKHR = Flags; - - //=== VK_KHR_display === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DisplayModeCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DisplayPlaneAlphaFlagBitsKHR::eOpaque ) | VkFlags( DisplayPlaneAlphaFlagBitsKHR::eGlobal ) | - VkFlags( DisplayPlaneAlphaFlagBitsKHR::ePerPixel ) | VkFlags( DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied ) - }; - }; - using DisplayPlaneAlphaFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DisplaySurfaceCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SurfaceTransformFlagBitsKHR::eIdentity ) | VkFlags( SurfaceTransformFlagBitsKHR::eRotate90 ) | - VkFlags( SurfaceTransformFlagBitsKHR::eRotate180 ) | VkFlags( SurfaceTransformFlagBitsKHR::eRotate270 ) | - VkFlags( SurfaceTransformFlagBitsKHR::eHorizontalMirror ) | VkFlags( SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 ) | - VkFlags( SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 ) | VkFlags( SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 ) | - VkFlags( SurfaceTransformFlagBitsKHR::eInherit ) - }; - }; - using SurfaceTransformFlagsKHR = Flags; - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using XlibSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using XcbSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using WaylandSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using AndroidSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using Win32SurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DebugReportFlagBitsEXT::eInformation ) | VkFlags( DebugReportFlagBitsEXT::eWarning ) | - VkFlags( DebugReportFlagBitsEXT::ePerformanceWarning ) | VkFlags( DebugReportFlagBitsEXT::eError ) | VkFlags( DebugReportFlagBitsEXT::eDebug ) - }; - }; - using DebugReportFlagsEXT = Flags; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_video_queue === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoCodecOperationFlagBitsKHR::eNone ) | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH264EXT ) | - VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH265EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eDecodeH264EXT ) | - VkFlags( VideoCodecOperationFlagBitsKHR::eDecodeH265EXT ) - }; - }; - using VideoCodecOperationFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoChromaSubsamplingFlagBitsKHR::eInvalid ) | VkFlags( VideoChromaSubsamplingFlagBitsKHR::eMonochrome ) | - VkFlags( VideoChromaSubsamplingFlagBitsKHR::e420 ) | VkFlags( VideoChromaSubsamplingFlagBitsKHR::e422 ) | - VkFlags( VideoChromaSubsamplingFlagBitsKHR::e444 ) - }; - }; - using VideoChromaSubsamplingFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoComponentBitDepthFlagBitsKHR::eInvalid ) | VkFlags( VideoComponentBitDepthFlagBitsKHR::e8 ) | - VkFlags( VideoComponentBitDepthFlagBitsKHR::e10 ) | VkFlags( VideoComponentBitDepthFlagBitsKHR::e12 ) - }; - }; - using VideoComponentBitDepthFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoCapabilityFlagBitsKHR::eProtectedContent ) | VkFlags( VideoCapabilityFlagBitsKHR::eSeparateReferenceImages ) - }; - }; - using VideoCapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoSessionCreateFlagBitsKHR::eProtectedContent ) - }; - }; - using VideoSessionCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using VideoSessionParametersCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using VideoBeginCodingFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using VideoEndCodingFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoCodingControlFlagBitsKHR::eReset ) | VkFlags( VideoCodingControlFlagBitsKHR::eEncodeRateControl ) | - VkFlags( VideoCodingControlFlagBitsKHR::eEncodeRateControlLayer ) - }; - }; - using VideoCodingControlFlagsKHR = Flags; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_video_decode_queue === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide ) | VkFlags( VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct ) - }; - }; - using VideoDecodeCapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoDecodeUsageFlagBitsKHR::eDefault ) | VkFlags( VideoDecodeUsageFlagBitsKHR::eTranscoding ) | - VkFlags( VideoDecodeUsageFlagBitsKHR::eOffline ) | VkFlags( VideoDecodeUsageFlagBitsKHR::eStreaming ) - }; - }; - using VideoDecodeUsageFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using VideoDecodeFlagsKHR = Flags; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_transform_feedback === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineRasterizationStateStreamCreateFlagsEXT = Flags; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_EXT_video_encode_h264 === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceEnabled ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceDisabled ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::ePicInitQpMinus26 ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPred ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredExplicit ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredImplicit ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPredNoTable ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List ) - }; - }; - using VideoEncodeH264CapabilityFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eFrame ) | VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eSlice ) | - VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eNonVcl ) - }; - }; - using VideoEncodeH264InputModeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eFrame ) | VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eSlice ) | - VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl ) - }; - }; - using VideoEncodeH264OutputModeFlagsEXT = Flags; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_EXT_video_encode_h265 === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSeparateColourPlane ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eScalingLists ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSampleAdaptiveOffsetEnabled ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::ePcmEnable ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSpsTemporalMvpEnabled ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eInitQpMinus26 ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2 ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipDisabled ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPredNoTable ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eTransquantBypassEnabled ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eEntropyCodingSyncEnabled ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDeblockingFilterOverrideEnabled ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerFrame ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSlicePerTile ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerSlice ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSliceSegmentCtbCount ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment ) | - VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List ) - }; - }; - using VideoEncodeH265CapabilityFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeH265InputModeFlagBitsEXT::eFrame ) | VkFlags( VideoEncodeH265InputModeFlagBitsEXT::eSliceSegment ) | - VkFlags( VideoEncodeH265InputModeFlagBitsEXT::eNonVcl ) - }; - }; - using VideoEncodeH265InputModeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeH265OutputModeFlagBitsEXT::eFrame ) | VkFlags( VideoEncodeH265OutputModeFlagBitsEXT::eSliceSegment ) | - VkFlags( VideoEncodeH265OutputModeFlagBitsEXT::eNonVcl ) - }; - }; - using VideoEncodeH265OutputModeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e16 ) | VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e32 ) | - VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e64 ) - }; - }; - using VideoEncodeH265CtbSizeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4 ) | VkFlags( VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8 ) | - VkFlags( VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16 ) | VkFlags( VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32 ) - }; - }; - using VideoEncodeH265TransformBlockSizeFlagsEXT = Flags; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_EXT_video_decode_h264 === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eProgressive ) | - VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines ) | - VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes ) - }; - }; - using VideoDecodeH264PictureLayoutFlagsEXT = Flags; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using StreamDescriptorSurfaceCreateFlagsGGP = Flags; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 ) | VkFlags( ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt ) | - VkFlags( ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image ) | VkFlags( ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt ) - }; - }; - using ExternalMemoryHandleTypeFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly ) | VkFlags( ExternalMemoryFeatureFlagBitsNV::eExportable ) | - VkFlags( ExternalMemoryFeatureFlagBitsNV::eImportable ) - }; - }; - using ExternalMemoryFeatureFlagsNV = Flags; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using ViSurfaceCreateFlagsNN = Flags; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_EXT_conditional_rendering === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ConditionalRenderingFlagBitsEXT::eInverted ) - }; - }; - using ConditionalRenderingFlagsEXT = Flags; - - //=== VK_EXT_display_surface_counter === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( SurfaceCounterFlagBitsEXT::eVblank ) - }; - }; - using SurfaceCounterFlagsEXT = Flags; - - //=== VK_NV_viewport_swizzle === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineViewportSwizzleStateCreateFlagsNV = Flags; - - //=== VK_EXT_discard_rectangles === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; - - //=== VK_EXT_conservative_rasterization === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags; - - //=== VK_EXT_depth_clip_enable === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags; - - //=== VK_KHR_performance_query === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = - VkFlags( PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting ) | VkFlags( PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted ) - }; - }; - using PerformanceCounterDescriptionFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using AcquireProfilingLockFlagsKHR = Flags; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using IOSSurfaceCreateFlagsMVK = Flags; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using MacOSSurfaceCreateFlagsMVK = Flags; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DebugUtilsMessageSeverityFlagBitsEXT::eVerbose ) | VkFlags( DebugUtilsMessageSeverityFlagBitsEXT::eInfo ) | - VkFlags( DebugUtilsMessageSeverityFlagBitsEXT::eWarning ) | VkFlags( DebugUtilsMessageSeverityFlagBitsEXT::eError ) - }; - }; - using DebugUtilsMessageSeverityFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DebugUtilsMessageTypeFlagBitsEXT::eGeneral ) | VkFlags( DebugUtilsMessageTypeFlagBitsEXT::eValidation ) | - VkFlags( DebugUtilsMessageTypeFlagBitsEXT::ePerformance ) | VkFlags( DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding ) - }; - }; - using DebugUtilsMessageTypeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DebugUtilsMessengerCallbackDataFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DebugUtilsMessengerCreateFlagsEXT = Flags; - - //=== VK_NV_fragment_coverage_to_color === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineCoverageToColorStateCreateFlagsNV = Flags; - - //=== VK_KHR_acceleration_structure === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( GeometryFlagBitsKHR::eOpaque ) | VkFlags( GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation ) - }; - }; - using GeometryFlagsKHR = Flags; - using GeometryFlagsNV = GeometryFlagsKHR; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable ) | VkFlags( GeometryInstanceFlagBitsKHR::eTriangleFlipFacing ) | - VkFlags( GeometryInstanceFlagBitsKHR::eForceOpaque ) | VkFlags( GeometryInstanceFlagBitsKHR::eForceNoOpaque ) | - VkFlags( GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT ) | VkFlags( GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT ) - }; - }; - using GeometryInstanceFlagsKHR = Flags; - using GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( BuildAccelerationStructureFlagBitsKHR::eAllowUpdate ) | VkFlags( BuildAccelerationStructureFlagBitsKHR::eAllowCompaction ) | - VkFlags( BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace ) | VkFlags( BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild ) | - VkFlags( BuildAccelerationStructureFlagBitsKHR::eLowMemory ) | VkFlags( BuildAccelerationStructureFlagBitsKHR::eMotionNV ) | - VkFlags( BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT ) | - VkFlags( BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT ) | - VkFlags( BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT ) - }; - }; - using BuildAccelerationStructureFlagsKHR = Flags; - using BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay ) | VkFlags( AccelerationStructureCreateFlagBitsKHR::eMotionNV ) - }; - }; - using AccelerationStructureCreateFlagsKHR = Flags; - - //=== VK_NV_framebuffer_mixed_samples === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineCoverageModulationStateCreateFlagsNV = Flags; - - //=== VK_EXT_validation_cache === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using ValidationCacheCreateFlagsEXT = Flags; - - //=== VK_AMD_pipeline_compiler_control === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineCompilerControlFlagsAMD = Flags; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using MetalSurfaceCreateFlagsEXT = Flags; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_AMD_shader_core_properties2 === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using ShaderCorePropertiesFlagsAMD = Flags; - - //=== VK_NV_coverage_reduction_mode === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using PipelineCoverageReductionStateCreateFlagsNV = Flags; - - //=== VK_EXT_headless_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using HeadlessSurfaceCreateFlagsEXT = Flags; - - //=== VK_NV_device_generated_commands === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( IndirectStateFlagBitsNV::eFlagFrontface ) - }; - }; - using IndirectStateFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess ) | VkFlags( IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences ) | - VkFlags( IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences ) - }; - }; - using IndirectCommandsLayoutUsageFlagsNV = Flags; - - //=== VK_EXT_device_memory_report === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DeviceMemoryReportFlagsEXT = Flags; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_video_encode_queue === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using VideoEncodeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes ) - }; - }; - using VideoEncodeCapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeUsageFlagBitsKHR::eDefault ) | VkFlags( VideoEncodeUsageFlagBitsKHR::eTranscoding ) | - VkFlags( VideoEncodeUsageFlagBitsKHR::eStreaming ) | VkFlags( VideoEncodeUsageFlagBitsKHR::eRecording ) | - VkFlags( VideoEncodeUsageFlagBitsKHR::eConferencing ) - }; - }; - using VideoEncodeUsageFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeContentFlagBitsKHR::eDefault ) | VkFlags( VideoEncodeContentFlagBitsKHR::eCamera ) | - VkFlags( VideoEncodeContentFlagBitsKHR::eDesktop ) | VkFlags( VideoEncodeContentFlagBitsKHR::eRendered ) - }; - }; - using VideoEncodeContentFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using VideoEncodeRateControlFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( VideoEncodeRateControlModeFlagBitsKHR::eNone ) | VkFlags( VideoEncodeRateControlModeFlagBitsKHR::eCbr ) | - VkFlags( VideoEncodeRateControlModeFlagBitsKHR::eVbr ) - }; - }; - using VideoEncodeRateControlModeFlagsKHR = Flags; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_NV_device_diagnostics_config === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo ) | VkFlags( DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking ) | - VkFlags( DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints ) | - VkFlags( DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting ) - }; - }; - using DeviceDiagnosticsConfigFlagsNV = Flags; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ExportMetalObjectTypeFlagBitsEXT::eMetalDevice ) | VkFlags( ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue ) | - VkFlags( ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer ) | VkFlags( ExportMetalObjectTypeFlagBitsEXT::eMetalTexture ) | - VkFlags( ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface ) | VkFlags( ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent ) - }; - }; - using ExportMetalObjectTypeFlagsEXT = Flags; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_graphics_pipeline_library === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface ) | - VkFlags( GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders ) | VkFlags( GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader ) | - VkFlags( GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface ) - }; - }; - using GraphicsPipelineLibraryFlagsEXT = Flags; - - //=== VK_NV_ray_tracing_motion_blur === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using AccelerationStructureMotionInfoFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using AccelerationStructureMotionInstanceFlagsNV = Flags; - - //=== VK_EXT_image_compression_control === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ImageCompressionFlagBitsEXT::eDefault ) | VkFlags( ImageCompressionFlagBitsEXT::eFixedRateDefault ) | - VkFlags( ImageCompressionFlagBitsEXT::eFixedRateExplicit ) | VkFlags( ImageCompressionFlagBitsEXT::eDisabled ) - }; - }; - using ImageCompressionFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ImageCompressionFixedRateFlagBitsEXT::eNone ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e1Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e2Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e3Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e4Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e5Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e6Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e7Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e8Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e9Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e10Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e11Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e12Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e13Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e14Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e15Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e16Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e17Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e18Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e19Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e20Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e21Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e22Bpc ) | VkFlags( ImageCompressionFixedRateFlagBitsEXT::e23Bpc ) | - VkFlags( ImageCompressionFixedRateFlagBitsEXT::e24Bpc ) - }; - }; - using ImageCompressionFixedRateFlagsEXT = Flags; - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using DirectFBSurfaceCreateFlagsEXT = Flags; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_device_address_binding_report === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( DeviceAddressBindingFlagBitsEXT::eInternalObject ) - }; - }; - using DeviceAddressBindingFlagsEXT = Flags; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using ImageFormatConstraintsFlagsFUCHSIA = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely ) | VkFlags( ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften ) | - VkFlags( ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely ) | VkFlags( ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften ) | - VkFlags( ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional ) - }; - }; - using ImageConstraintsInfoFlagsFUCHSIA = Flags; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = 0 - }; - }; - using ScreenSurfaceCreateFlagsQNX = Flags; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_opacity_micromap === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( BuildMicromapFlagBitsEXT::ePreferFastTrace ) | VkFlags( BuildMicromapFlagBitsEXT::ePreferFastBuild ) | - VkFlags( BuildMicromapFlagBitsEXT::eAllowCompaction ) - }; - }; - using BuildMicromapFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay ) - }; - }; - using MicromapCreateFlagsEXT = Flags; - - //=== VK_NV_optical_flow === - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( OpticalFlowUsageFlagBitsNV::eUnknown ) | VkFlags( OpticalFlowUsageFlagBitsNV::eInput ) | - VkFlags( OpticalFlowUsageFlagBitsNV::eOutput ) | VkFlags( OpticalFlowUsageFlagBitsNV::eHint ) | VkFlags( OpticalFlowUsageFlagBitsNV::eCost ) | - VkFlags( OpticalFlowUsageFlagBitsNV::eGlobalFlow ) - }; - }; - using OpticalFlowUsageFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( OpticalFlowGridSizeFlagBitsNV::eUnknown ) | VkFlags( OpticalFlowGridSizeFlagBitsNV::e1X1 ) | - VkFlags( OpticalFlowGridSizeFlagBitsNV::e2X2 ) | VkFlags( OpticalFlowGridSizeFlagBitsNV::e4X4 ) | - VkFlags( OpticalFlowGridSizeFlagBitsNV::e8X8 ) - }; - }; - using OpticalFlowGridSizeFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( OpticalFlowSessionCreateFlagBitsNV::eEnableHint ) | VkFlags( OpticalFlowSessionCreateFlagBitsNV::eEnableCost ) | - VkFlags( OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow ) | VkFlags( OpticalFlowSessionCreateFlagBitsNV::eAllowRegions ) | - VkFlags( OpticalFlowSessionCreateFlagBitsNV::eBothDirections ) - }; - }; - using OpticalFlowSessionCreateFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - - enum : VkFlags - { - allFlags = VkFlags( OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints ) - }; - }; - using OpticalFlowExecuteFlagsNV = Flags; } // namespace VULKAN_HPP_NAMESPACE #endif