for ( auto const & type : require.types )
{
auto bitmaskIt = m_bitmasks.find( type );
- if ( ( bitmaskIt != m_bitmasks.end() ) && bitmaskIt->second.require.empty() )
+ if ( bitmaskIt != m_bitmasks.end() )
{
- // generate the flagBits enum name out of the bitmask name: VkFooFlagsXXX -> VkFooFlagBitsXXX
- size_t pos = bitmaskIt->first.find( "Flags" );
- assert( pos != std::string::npos );
- std::string flagBits = bitmaskIt->first.substr( 0, pos + 4 ) + "Bit" + bitmaskIt->first.substr( pos + 4 );
+ if ( bitmaskIt->second.require.empty() )
+ {
+ // generate the flagBits enum name out of the bitmask name: VkFooFlagsXXX -> VkFooFlagBitsXXX
+ size_t pos = bitmaskIt->first.find( "Flags" );
+ assert( pos != std::string::npos );
+ std::string flagBits = bitmaskIt->first.substr( 0, pos + 4 ) + "Bit" + bitmaskIt->first.substr( pos + 4 );
- // as the bitmask's requirement is still empty, this flagBits should not be listed in the require list!
- assert( std::none_of( require.types.begin(), require.types.end(), [&flagBits]( std::string const & type ) { return ( type == flagBits ); } ) );
+ // as the bitmask's requirement is still empty, this flagBits should not be listed in the require list!
+ assert( std::none_of( require.types.begin(), require.types.end(), [&flagBits]( std::string const & type ) { return ( type == flagBits ); } ) );
- bitmaskIt->second.require = flagBits;
+ bitmaskIt->second.require = flagBits;
- // 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
- auto enumIt = m_enums.find( flagBits );
- if ( enumIt == m_enums.end() )
- {
- m_enums.insert( std::make_pair( flagBits, EnumData{ .isBitmask = true, .xmlLine = 0 } ) );
+ // 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
+ auto enumIt = m_enums.find( flagBits );
+ if ( enumIt == m_enums.end() )
+ {
+ m_enums.insert( std::make_pair( flagBits, EnumData{ .isBitmask = true, .xmlLine = 0 } ) );
+
+ assert( !m_types.contains( flagBits ) );
+ m_types.insert( std::make_pair( flagBits, TypeData{ TypeCategory::Bitmask, { requiredBy }, 0 } ) );
+ }
+ else
+ {
+ assert( m_types.contains( flagBits ) );
+ enumIt->second.isBitmask = true;
+ }
- assert( !m_types.contains( flagBits ) );
- m_types.insert( std::make_pair( flagBits, TypeData{ TypeCategory::Bitmask, { requiredBy }, 0 } ) );
+ newTypes.push_back( flagBits );
}
- else
+ else if ( std::find( require.types.begin(), require.types.end(), bitmaskIt->second.require ) == require.types.end() )
{
- assert( m_types.contains( flagBits ) );
- enumIt->second.isBitmask = true;
+ // this bitmask requires a flags type that is not listed in here, so add it
+ newTypes.push_back( bitmaskIt->second.require );
}
-
- newTypes.push_back( flagBits );
}
}
// add all the newly created flagBits types to the require list as if they had been part of the vk.xml!
)" };
auto const hardCodedTypes = std::array{ "ArrayWrapper1D", "ArrayWrapper2D", "FlagTraits", "Flags", "DispatchLoaderBase", "DispatchLoaderDynamic" };
- auto const hardCodedEnhancedModeTypes =
- std::array{ "ArrayProxy", "ArrayProxyNoTemporaries", "StridedArrayProxy", "Optional", "StructureChain" };
- auto const hardCodedSmartHandleTypes = std::array{ "ObjectDestroy", "ObjectFree", "ObjectRelease", "PoolFree",
- "ObjectDestroyShared", "ObjectFreeShared", "ObjectReleaseShared", "PoolFreeShared",
- "SharedHandle", "UniqueHandle"};
+ auto const hardCodedEnhancedModeTypes = std::array{ "ArrayProxy", "ArrayProxyNoTemporaries", "StridedArrayProxy", "Optional", "StructureChain" };
+ auto const hardCodedSmartHandleTypes = std::array{ "ObjectDestroy", "ObjectFree", "ObjectRelease", "PoolFree", "ObjectDestroyShared",
+ "ObjectFreeShared", "ObjectReleaseShared", "PoolFreeShared", "SharedHandle", "UniqueHandle" };
auto usings = std::string{ R"( //=====================================
//=== HARDCODED TYPEs AND FUNCTIONs ===
{
bitpos = attribute.second;
}
- if ( attribute.first == "extends" )
+ else if ( attribute.first == "extends" )
{
extends = attribute.second;
}
using VULKAN_HPP_NAMESPACE::DescriptorType;
using VULKAN_HPP_NAMESPACE::DeviceCreateFlagBits;
using VULKAN_HPP_NAMESPACE::DeviceCreateFlags;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags;
using VULKAN_HPP_NAMESPACE::DynamicState;
using VULKAN_HPP_NAMESPACE::EventCreateFlagBits;
using VULKAN_HPP_NAMESPACE::EventCreateFlags;
using VULKAN_HPP_NAMESPACE::ObjectType;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceType;
using VULKAN_HPP_NAMESPACE::PipelineBindPoint;
+ using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion;
+ using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits;
using VULKAN_HPP_NAMESPACE::PipelineCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlagBits;
using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlagBits;
using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlagBits;
using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlagBits;
using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags;
using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType;
using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateTypeKHR;
- using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits;
- using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags;
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBits;
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags;
using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagBitsEXT;
using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT;
- //=== VK_EXT_pipeline_creation_cache_control ===
- using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits;
- using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags;
-
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_encode_queue ===
using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagBitsKHR;
//=== VK_EXT_graphics_pipeline_library ===
using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagBitsEXT;
using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagsEXT;
- using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits;
- using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags;
//=== VK_NV_fragment_shading_rate_enums ===
using VULKAN_HPP_NAMESPACE::FragmentShadingRateNV;
using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG;
using VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG;
- //=== VK_EXT_rasterization_order_attachment_access ===
- using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits;
- using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags;
- using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits;
- using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags;
-
//=== VK_NV_optical_flow ===
using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagBitsNV;
using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagsNV;
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceCreateFlags allFlags = {};
};
+ enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
+ {
+ eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
+ };
+
+ using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
+
+ template <>
+ struct FlagTraits<DeviceQueueCreateFlagBits>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = DeviceQueueCreateFlagBits::eProtected;
+ };
+
enum class PipelineStageFlagBits : VkPipelineStageFlags
{
eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderModuleCreateFlags allFlags = {};
};
+ enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags
+ {
+ eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
+ eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT
+ };
+
+ using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
+
+ template <>
+ struct FlagTraits<PipelineCacheCreateFlagBits>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = PipelineCacheCreateFlagBits::eExternallySynchronized;
+ };
+
enum class BlendFactor
{
eZero = VK_BLEND_FACTOR_ZERO,
eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
};
+ enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags
+ {
+ eRasterizationOrderAttachmentAccessARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM,
+ eRasterizationOrderAttachmentAccessEXT = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT
+ };
+
+ using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits>;
+
+ template <>
+ struct FlagTraits<PipelineColorBlendStateCreateFlagBits>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags =
+ PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT;
+ };
+
+ enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags
+ {
+ eRasterizationOrderAttachmentDepthAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM,
+ eRasterizationOrderAttachmentStencilAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM,
+ eRasterizationOrderAttachmentDepthAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT,
+ eRasterizationOrderAttachmentStencilAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT
+ };
+
+ using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits>;
+
+ template <>
+ struct FlagTraits<PipelineDepthStencilStateCreateFlagBits>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDepthStencilStateCreateFlags allFlags =
+ PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT |
+ PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT;
+ };
+
enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags
{
};
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineInputAssemblyStateCreateFlags allFlags = {};
};
+ enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags
+ {
+ eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT
+ };
+
+ using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
+
+ template <>
+ struct FlagTraits<PipelineLayoutCreateFlagBits>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT;
+ };
+
enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags
{
};
};
using TessellationDomainOriginKHR = TessellationDomainOrigin;
- enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
- {
- eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
- };
-
- using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
-
- template <>
- struct FlagTraits<DeviceQueueCreateFlagBits>
- {
- 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,
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceMemoryReportFlagsEXT allFlags = {};
};
- //=== VK_EXT_pipeline_creation_cache_control ===
-
- enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags
- {
- eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
- eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT
- };
-
- using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
-
- template <>
- struct FlagTraits<PipelineCacheCreateFlagBits>
- {
- 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 ===
GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader | GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface;
};
- enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags
- {
- eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT
- };
-
- using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
-
- template <>
- struct FlagTraits<PipelineLayoutCreateFlagBits>
- {
- 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
static VULKAN_HPP_CONST_OR_CONSTEXPR DirectDriverLoadingFlagsLUNARG allFlags = {};
};
- //=== VK_EXT_rasterization_order_attachment_access ===
-
- enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags
- {
- eRasterizationOrderAttachmentAccessARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM,
- eRasterizationOrderAttachmentAccessEXT = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT
- };
-
- using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits>;
-
- template <>
- struct FlagTraits<PipelineColorBlendStateCreateFlagBits>
- {
- static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
- static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags =
- PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT;
- };
-
- enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags
- {
- eRasterizationOrderAttachmentDepthAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM,
- eRasterizationOrderAttachmentStencilAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM,
- eRasterizationOrderAttachmentDepthAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT,
- eRasterizationOrderAttachmentStencilAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT
- };
-
- using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits>;
-
- template <>
- struct FlagTraits<PipelineDepthStencilStateCreateFlagBits>
- {
- 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
return "(void)";
}
+ VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case DeviceQueueCreateFlagBits::eProtected: return "Protected";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits value )
{
switch ( value )
return "(void)";
}
+ VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case PipelineCacheCreateFlagBits::eExternallySynchronized: return "ExternallySynchronized";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
VULKAN_HPP_INLINE std::string to_string( BlendFactor value )
{
switch ( value )
}
}
+ VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT: return "RasterizationOrderAttachmentDepthAccessEXT";
+ case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
{
return "(void)";
return "(void)";
}
+ VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
{
return "(void)";
}
}
- VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value )
- {
- switch ( value )
- {
- case DeviceQueueCreateFlagBits::eProtected: return "Protected";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrModelConversion value )
{
switch ( value )
return "(void)";
}
- //=== VK_EXT_pipeline_creation_cache_control ===
-
- VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits value )
- {
- switch ( value )
- {
- case PipelineCacheCreateFlagBits::eExternallySynchronized: return "ExternallySynchronized";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_encode_queue ===
}
}
- VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits value )
- {
- switch ( value )
- {
- case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
//=== VK_NV_fragment_shading_rate_enums ===
VULKAN_HPP_INLINE std::string to_string( FragmentShadingRateNV value )
return "(void)";
}
- //=== VK_EXT_rasterization_order_attachment_access ===
-
- VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits value )
- {
- switch ( value )
- {
- case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
- VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits value )
- {
- switch ( value )
- {
- case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT: return "RasterizationOrderAttachmentDepthAccessEXT";
- case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
//=== VK_NV_optical_flow ===
VULKAN_HPP_INLINE std::string to_string( OpticalFlowUsageFlagBitsNV value )
using VULKAN_HPP_NAMESPACE::ArrayProxy;
using VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries;
using VULKAN_HPP_NAMESPACE::Optional;
- using VULKAN_HPP_NAMESPACE::SharedHandle;
using VULKAN_HPP_NAMESPACE::StridedArrayProxy;
using VULKAN_HPP_NAMESPACE::StructureChain;
- using VULKAN_HPP_NAMESPACE::UniqueHandle;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
using VULKAN_HPP_NAMESPACE::PoolFree;
using VULKAN_HPP_NAMESPACE::PoolFreeShared;
+ using VULKAN_HPP_NAMESPACE::SharedHandle;
+ using VULKAN_HPP_NAMESPACE::UniqueHandle;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
//==================
using VULKAN_HPP_NAMESPACE::DescriptorType;
using VULKAN_HPP_NAMESPACE::DeviceCreateFlagBits;
using VULKAN_HPP_NAMESPACE::DeviceCreateFlags;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags;
using VULKAN_HPP_NAMESPACE::DynamicState;
using VULKAN_HPP_NAMESPACE::EventCreateFlagBits;
using VULKAN_HPP_NAMESPACE::EventCreateFlags;
using VULKAN_HPP_NAMESPACE::ObjectType;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceType;
using VULKAN_HPP_NAMESPACE::PipelineBindPoint;
+ using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion;
using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits;
using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlagBits;
using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlagBits;
using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlagBits;
//=== VK_VERSION_1_1 ===
using VULKAN_HPP_NAMESPACE::ChromaLocation;
using VULKAN_HPP_NAMESPACE::ChromaLocationKHR;
- using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits;
- using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags;
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBits;
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags;
using VULKAN_HPP_NAMESPACE::FaultLevel;
using VULKAN_HPP_NAMESPACE::FaultQueryBehavior;
using VULKAN_HPP_NAMESPACE::FaultType;
- using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits;
- using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags;
using VULKAN_HPP_NAMESPACE::PipelineCacheValidationVersion;
using VULKAN_HPP_NAMESPACE::PipelineMatchControl;
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceCreateFlags allFlags = {};
};
+ enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
+ {
+ eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
+ };
+
+ using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
+
+ template <>
+ struct FlagTraits<DeviceQueueCreateFlagBits>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = DeviceQueueCreateFlagBits::eProtected;
+ };
+
enum class PipelineStageFlagBits : VkPipelineStageFlags
{
eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
};
+ enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags
+ {
+ eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
+ eReadOnly = VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT,
+ eUseApplicationStorage = VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT
+ };
+
+ using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
+
+ template <>
+ struct FlagTraits<PipelineCacheCreateFlagBits>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags =
+ PipelineCacheCreateFlagBits::eExternallySynchronized | PipelineCacheCreateFlagBits::eReadOnly | PipelineCacheCreateFlagBits::eUseApplicationStorage;
+ };
+
enum class BlendFactor
{
eZero = VK_BLEND_FACTOR_ZERO,
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineInputAssemblyStateCreateFlags allFlags = {};
};
+ enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags
+ {
+ };
+
+ using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
+
+ template <>
+ struct FlagTraits<PipelineLayoutCreateFlagBits>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = {};
+ };
+
enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags
{
};
};
using TessellationDomainOriginKHR = TessellationDomainOrigin;
- enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
- {
- eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
- };
-
- using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
-
- template <>
- struct FlagTraits<DeviceQueueCreateFlagBits>
- {
- 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,
eApplicationUuidExactMatch = VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH
};
- enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags
- {
- eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
- eReadOnly = VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT,
- eUseApplicationStorage = VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT
- };
-
- using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
-
- template <>
- struct FlagTraits<PipelineCacheCreateFlagBits>
- {
- static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
- static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags =
- PipelineCacheCreateFlagBits::eExternallySynchronized | PipelineCacheCreateFlagBits::eReadOnly | PipelineCacheCreateFlagBits::eUseApplicationStorage;
- };
-
enum class PipelineCacheValidationVersion
{
eSafetyCriticalOne = VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE
return "(void)";
}
+ VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case DeviceQueueCreateFlagBits::eProtected: return "Protected";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits value )
{
switch ( value )
}
}
+ VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case PipelineCacheCreateFlagBits::eExternallySynchronized: return "ExternallySynchronized";
+ case PipelineCacheCreateFlagBits::eReadOnly: return "ReadOnly";
+ case PipelineCacheCreateFlagBits::eUseApplicationStorage: return "UseApplicationStorage";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
VULKAN_HPP_INLINE std::string to_string( BlendFactor value )
{
switch ( value )
return "(void)";
}
+ VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits )
+ {
+ return "(void)";
+ }
+
VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
{
return "(void)";
}
}
- VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value )
- {
- switch ( value )
- {
- case DeviceQueueCreateFlagBits::eProtected: return "Protected";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrModelConversion value )
{
switch ( value )
}
}
- VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits value )
- {
- switch ( value )
- {
- case PipelineCacheCreateFlagBits::eExternallySynchronized: return "ExternallySynchronized";
- case PipelineCacheCreateFlagBits::eReadOnly: return "ReadOnly";
- case PipelineCacheCreateFlagBits::eUseApplicationStorage: return "UseApplicationStorage";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
VULKAN_HPP_INLINE std::string to_string( PipelineCacheValidationVersion value )
{
switch ( value )
projects / platform / upstream / Vulkan-Hpp.git / commitdiff