mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #1461 from KhronosGroup/update-vulkan-headers-pr

Browse Source 
Update Vulkan-Headers to v1.3.236
This commit is contained in:
Andreas Süßenbach 2022-12-06 16:49:13 +01:00 committed by GitHub
commit 4848fc8e6a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 1240 additions and 704 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit b7a86d3b2bf8fbe73fcd40df9ec62a5966e9db89 Subproject commit 2826791bed6a793f164bf534cd859968f13df8a9

34
vulkan/vulkan.hpp
View File

@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span> # include <span>
#endif #endif
static_assert( VK_HEADER_VERSION == 235, "Wrong VK_HEADER_VERSION!" ); static_assert( VK_HEADER_VERSION == 236, "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default. // 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@ -747,7 +747,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
template <std::size_t C> template <std::size_t C>
ArrayProxyNoTemporaries( T( &&ptr )[C] ) = delete; ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete;
template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
@ -757,7 +757,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( typename std::remove_const<T>::type( &&ptr )[C] ) = delete; ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &&ptr )[C] ) = delete;
ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( list.size() ) ) : m_count( static_cast<uint32_t>( list.size() ) )
@ -12010,6 +12010,16 @@ namespace VULKAN_HPP_NAMESPACE
}; };
}; };
//=== VK_LUNARG_direct_driver_loading ===
template <>
struct StructExtends<DirectDriverLoadingListLUNARG, InstanceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_module_identifier === //=== VK_EXT_shader_module_identifier ===
template <> template <>
struct StructExtends<PhysicalDeviceShaderModuleIdentifierFeaturesEXT, PhysicalDeviceFeatures2> struct StructExtends<PhysicalDeviceShaderModuleIdentifierFeaturesEXT, PhysicalDeviceFeatures2>
@ -12192,6 +12202,24 @@ namespace VULKAN_HPP_NAMESPACE
}; };
}; };
//=== VK_QCOM_multiview_per_view_viewports ===
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_ray_tracing_invocation_reorder === //=== VK_NV_ray_tracing_invocation_reorder ===
template <> template <>
struct StructExtends<PhysicalDeviceRayTracingInvocationReorderPropertiesNV, PhysicalDeviceProperties2> struct StructExtends<PhysicalDeviceRayTracingInvocationReorderPropertiesNV, PhysicalDeviceProperties2>

24
vulkan/vulkan_enums.hpp
View File

@ -849,6 +849,8 @@ namespace VULKAN_HPP_NAMESPACE
eRenderPassCreationControlEXT = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT, eRenderPassCreationControlEXT = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT,
eRenderPassCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT, eRenderPassCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT,
eRenderPassSubpassFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT, eRenderPassSubpassFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT,
eDirectDriverLoadingInfoLUNARG = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG,
eDirectDriverLoadingListLUNARG = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG,
ePhysicalDeviceShaderModuleIdentifierFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, ePhysicalDeviceShaderModuleIdentifierFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT,
ePhysicalDeviceShaderModuleIdentifierPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT, ePhysicalDeviceShaderModuleIdentifierPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT,
ePipelineShaderStageModuleIdentifierCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT, ePipelineShaderStageModuleIdentifierCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT,
@ -867,6 +869,7 @@ namespace VULKAN_HPP_NAMESPACE
eTilePropertiesQCOM = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM, eTilePropertiesQCOM = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM,
ePhysicalDeviceAmigoProfilingFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, ePhysicalDeviceAmigoProfilingFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC,
eAmigoProfilingSubmitInfoSEC = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC, eAmigoProfilingSubmitInfoSEC = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC,
ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM,
ePhysicalDeviceRayTracingInvocationReorderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, ePhysicalDeviceRayTracingInvocationReorderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV,
ePhysicalDeviceRayTracingInvocationReorderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV, ePhysicalDeviceRayTracingInvocationReorderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV,
ePhysicalDeviceMutableDescriptorTypeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, ePhysicalDeviceMutableDescriptorTypeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT,
@ -6273,6 +6276,27 @@ namespace VULKAN_HPP_NAMESPACE
eNotMergedUnspecified = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT eNotMergedUnspecified = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT
}; };
//=== VK_LUNARG_direct_driver_loading ===
enum class DirectDriverLoadingModeLUNARG
{
eExclusive = VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG,
eInclusive = VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG
};
enum class DirectDriverLoadingFlagBitsLUNARG : VkDirectDriverLoadingFlagsLUNARG
{
};
using DirectDriverLoadingFlagsLUNARG = Flags<DirectDriverLoadingFlagBitsLUNARG>;
template <>
struct FlagTraits<DirectDriverLoadingFlagBitsLUNARG>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR DirectDriverLoadingFlagsLUNARG allFlags = {};
};
//=== VK_EXT_rasterization_order_attachment_access === //=== VK_EXT_rasterization_order_attachment_access ===
enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags

1
vulkan/vulkan_format_traits.hpp
View File

@ -12,6 +12,7 @@
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
//===================== //=====================
//=== Format Traits === //=== Format Traits ===
//===================== //=====================

1
vulkan/vulkan_funcs.hpp
View File

@ -10,6 +10,7 @@
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
//=========================== //===========================
//=== COMMAND Definitions === //=== COMMAND Definitions ===
//=========================== //===========================

8
vulkan/vulkan_handles.hpp
View File

@ -10,6 +10,7 @@
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
//=================================== //===================================
//=== STRUCT forward declarations === //=== STRUCT forward declarations ===
//=================================== //===================================
@ -1496,6 +1497,10 @@ namespace VULKAN_HPP_NAMESPACE
struct RenderPassSubpassFeedbackInfoEXT; struct RenderPassSubpassFeedbackInfoEXT;
struct RenderPassSubpassFeedbackCreateInfoEXT; struct RenderPassSubpassFeedbackCreateInfoEXT;
//=== VK_LUNARG_direct_driver_loading ===
struct DirectDriverLoadingInfoLUNARG;
struct DirectDriverLoadingListLUNARG;
//=== VK_EXT_shader_module_identifier === //=== VK_EXT_shader_module_identifier ===
struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT; struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT; struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
@ -1529,6 +1534,9 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceAmigoProfilingFeaturesSEC; struct PhysicalDeviceAmigoProfilingFeaturesSEC;
struct AmigoProfilingSubmitInfoSEC; struct AmigoProfilingSubmitInfoSEC;
//=== VK_QCOM_multiview_per_view_viewports ===
struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
//=== VK_NV_ray_tracing_invocation_reorder === //=== VK_NV_ray_tracing_invocation_reorder ===
struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV; struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV; struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;

48
vulkan/vulkan_hash.hpp
View File

@ -3657,6 +3657,35 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType );
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext );
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags );
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType );
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext );
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode );
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount );
VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers );
return seed;
}
};
# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT> struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT>
@ -8692,6 +8721,21 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties>
{ {
@ -13354,8 +13398,8 @@ namespace std
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pStdPictureInfo ); VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pStdPictureInfo );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.sliceCount ); VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.sliceSegmentCount );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pSliceOffsets ); VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pSliceSegmentOffsets );
return seed; return seed;
} }
}; };

90
vulkan/vulkan_raii.hpp
View File

@ -2513,7 +2513,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Context & operator=( Context const & ) = delete; Context & operator=( Context const & ) = delete;
Context & operator =( Context && rhs ) VULKAN_HPP_NOEXCEPT Context & operator=( Context && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -2613,7 +2613,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Instance & operator=( Instance const & ) = delete; Instance & operator=( Instance const & ) = delete;
Instance & operator =( Instance && rhs ) VULKAN_HPP_NOEXCEPT Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -3316,7 +3316,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Device & operator=( Device const & ) = delete; Device & operator=( Device const & ) = delete;
Device & operator =( Device && rhs ) VULKAN_HPP_NOEXCEPT Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -4190,7 +4190,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
AccelerationStructureKHR & operator=( AccelerationStructureKHR const & ) = delete; AccelerationStructureKHR & operator=( AccelerationStructureKHR const & ) = delete;
AccelerationStructureKHR & operator =( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -4311,7 +4311,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
AccelerationStructureNV & operator=( AccelerationStructureNV const & ) = delete; AccelerationStructureNV & operator=( AccelerationStructureNV const & ) = delete;
AccelerationStructureNV & operator =( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -4440,7 +4440,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Buffer & operator=( Buffer const & ) = delete; Buffer & operator=( Buffer const & ) = delete;
Buffer & operator =( Buffer && rhs ) VULKAN_HPP_NOEXCEPT Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -4567,7 +4567,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete; BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete;
BufferCollectionFUCHSIA & operator =( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -4697,7 +4697,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
BufferView & operator=( BufferView const & ) = delete; BufferView & operator=( BufferView const & ) = delete;
BufferView & operator =( BufferView && rhs ) VULKAN_HPP_NOEXCEPT BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -4817,7 +4817,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
CommandPool & operator=( CommandPool const & ) = delete; CommandPool & operator=( CommandPool const & ) = delete;
CommandPool & operator =( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -4926,7 +4926,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
CommandBuffer & operator=( CommandBuffer const & ) = delete; CommandBuffer & operator=( CommandBuffer const & ) = delete;
CommandBuffer & operator =( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -5936,7 +5936,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete; CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete;
CuFunctionNVX & operator =( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -6056,7 +6056,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
CuModuleNVX & operator=( CuModuleNVX const & ) = delete; CuModuleNVX & operator=( CuModuleNVX const & ) = delete;
CuModuleNVX & operator =( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -6176,7 +6176,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & ) = delete; DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & ) = delete;
DebugReportCallbackEXT & operator =( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -6297,7 +6297,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & ) = delete; DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & ) = delete;
DebugUtilsMessengerEXT & operator =( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -6416,7 +6416,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete; DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete;
DeferredOperationKHR & operator =( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -6545,7 +6545,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DescriptorPool & operator=( DescriptorPool const & ) = delete; DescriptorPool & operator=( DescriptorPool const & ) = delete;
DescriptorPool & operator =( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -6647,7 +6647,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DescriptorSet & operator=( DescriptorSet const & ) = delete; DescriptorSet & operator=( DescriptorSet const & ) = delete;
DescriptorSet & operator =( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -6816,7 +6816,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete; DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete;
DescriptorSetLayout & operator =( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -6943,7 +6943,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & ) = delete; DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & ) = delete;
DescriptorUpdateTemplate & operator =( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -7064,7 +7064,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DeviceMemory & operator=( DeviceMemory const & ) = delete; DeviceMemory & operator=( DeviceMemory const & ) = delete;
DeviceMemory & operator =( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -7217,7 +7217,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
DisplayKHR & operator=( DisplayKHR const & ) = delete; DisplayKHR & operator=( DisplayKHR const & ) = delete;
DisplayKHR & operator =( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -7499,7 +7499,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Event & operator=( Event const & ) = delete; Event & operator=( Event const & ) = delete;
Event & operator =( Event && rhs ) VULKAN_HPP_NOEXCEPT Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -7665,7 +7665,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Fence & operator=( Fence const & ) = delete; Fence & operator=( Fence const & ) = delete;
Fence & operator =( Fence && rhs ) VULKAN_HPP_NOEXCEPT Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -7789,7 +7789,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Framebuffer & operator=( Framebuffer const & ) = delete; Framebuffer & operator=( Framebuffer const & ) = delete;
Framebuffer & operator =( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -7913,7 +7913,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Image & operator=( Image const & ) = delete; Image & operator=( Image const & ) = delete;
Image & operator =( Image && rhs ) VULKAN_HPP_NOEXCEPT Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -8057,7 +8057,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
ImageView & operator=( ImageView const & ) = delete; ImageView & operator=( ImageView const & ) = delete;
ImageView & operator =( ImageView && rhs ) VULKAN_HPP_NOEXCEPT ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -8181,7 +8181,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & ) = delete; IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & ) = delete;
IndirectCommandsLayoutNV & operator =( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -8302,7 +8302,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
MicromapEXT & operator=( MicromapEXT const & ) = delete; MicromapEXT & operator=( MicromapEXT const & ) = delete;
MicromapEXT & operator =( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -8422,7 +8422,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & ) = delete; OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & ) = delete;
OpticalFlowSessionNV & operator =( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -8539,7 +8539,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & ) = delete; PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & ) = delete;
PerformanceConfigurationINTEL & operator =( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -8654,7 +8654,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
PipelineCache & operator=( PipelineCache const & ) = delete; PipelineCache & operator=( PipelineCache const & ) = delete;
PipelineCache & operator =( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -8858,7 +8858,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Pipeline & operator=( Pipeline const & ) = delete; Pipeline & operator=( Pipeline const & ) = delete;
Pipeline & operator =( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -9148,7 +9148,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
PipelineLayout & operator=( PipelineLayout const & ) = delete; PipelineLayout & operator=( PipelineLayout const & ) = delete;
PipelineLayout & operator =( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -9269,7 +9269,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
PrivateDataSlot & operator=( PrivateDataSlot const & ) = delete; PrivateDataSlot & operator=( PrivateDataSlot const & ) = delete;
PrivateDataSlot & operator =( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -9390,7 +9390,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
QueryPool & operator=( QueryPool const & ) = delete; QueryPool & operator=( QueryPool const & ) = delete;
QueryPool & operator =( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -9686,7 +9686,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
RenderPass & operator=( RenderPass const & ) = delete; RenderPass & operator=( RenderPass const & ) = delete;
RenderPass & operator =( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -9814,7 +9814,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Sampler & operator=( Sampler const & ) = delete; Sampler & operator=( Sampler const & ) = delete;
Sampler & operator =( Sampler && rhs ) VULKAN_HPP_NOEXCEPT Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -9934,7 +9934,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & ) = delete; SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & ) = delete;
SamplerYcbcrConversion & operator =( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -10055,7 +10055,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
Semaphore & operator=( Semaphore const & ) = delete; Semaphore & operator=( Semaphore const & ) = delete;
Semaphore & operator =( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -10183,7 +10183,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
ShaderModule & operator=( ShaderModule const & ) = delete; ShaderModule & operator=( ShaderModule const & ) = delete;
ShaderModule & operator =( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -10585,7 +10585,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
SurfaceKHR & operator=( SurfaceKHR const & ) = delete; SurfaceKHR & operator=( SurfaceKHR const & ) = delete;
SurfaceKHR & operator =( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -10705,7 +10705,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
SwapchainKHR & operator=( SwapchainKHR const & ) = delete; SwapchainKHR & operator=( SwapchainKHR const & ) = delete;
SwapchainKHR & operator =( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -10902,7 +10902,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete; ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete;
ValidationCacheEXT & operator =( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -11030,7 +11030,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete; VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete;
VideoSessionKHR & operator =( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
@ -11159,7 +11159,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete; VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete;
VideoSessionParametersKHR & operator =( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {

24
vulkan/vulkan_static_assertions.hpp
View File

@ -6070,6 +6070,20 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPa
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT>::value,
"RenderPassSubpassFeedbackCreateInfoEXT is not nothrow_move_constructible!" ); "RenderPassSubpassFeedbackCreateInfoEXT is not nothrow_move_constructible!" );
//=== VK_LUNARG_direct_driver_loading ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG ) == sizeof( VkDirectDriverLoadingInfoLUNARG ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG>::value,
"DirectDriverLoadingInfoLUNARG is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG ) == sizeof( VkDirectDriverLoadingListLUNARG ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG>::value,
"DirectDriverLoadingListLUNARG is not nothrow_move_constructible!" );
//=== VK_EXT_shader_module_identifier === //=== VK_EXT_shader_module_identifier ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT ) == VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT ) ==
@ -6212,6 +6226,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AmigoPro
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC>::value,
"AmigoProfilingSubmitInfoSEC is not nothrow_move_constructible!" ); "AmigoProfilingSubmitInfoSEC is not nothrow_move_constructible!" );
//=== VK_QCOM_multiview_per_view_viewports ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) ==
sizeof( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>::value,
"PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM is not nothrow_move_constructible!" );
//=== VK_NV_ray_tracing_invocation_reorder === //=== VK_NV_ray_tracing_invocation_reorder ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV ) == VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV ) ==

414
vulkan/vulkan_structs.hpp
View File

@ -12,6 +12,7 @@
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
//=============== //===============
//=== STRUCTS === //=== STRUCTS ===
//=============== //===============
@ -27250,6 +27251,247 @@ namespace VULKAN_HPP_NAMESPACE
using Type = DeviceQueueInfo2; using Type = DeviceQueueInfo2;
}; };
struct DirectDriverLoadingInfoLUNARG
{
using NativeType = VkDirectDriverLoadingInfoLUNARG;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDirectDriverLoadingInfoLUNARG;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DirectDriverLoadingInfoLUNARG( VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG flags_ = {},
PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, flags( flags_ )
, pfnGetInstanceProcAddr( pfnGetInstanceProcAddr_ )
{
}
VULKAN_HPP_CONSTEXPR DirectDriverLoadingInfoLUNARG( DirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DirectDriverLoadingInfoLUNARG( VkDirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT
: DirectDriverLoadingInfoLUNARG( *reinterpret_cast<DirectDriverLoadingInfoLUNARG const *>( &rhs ) )
{
}
DirectDriverLoadingInfoLUNARG & operator=( DirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
DirectDriverLoadingInfoLUNARG & operator=( VkDirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setFlags( VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG flags_ ) VULKAN_HPP_NOEXCEPT
{
flags = flags_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setPfnGetInstanceProcAddr( PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr_ ) VULKAN_HPP_NOEXCEPT
{
pfnGetInstanceProcAddr = pfnGetInstanceProcAddr_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkDirectDriverLoadingInfoLUNARG const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDirectDriverLoadingInfoLUNARG *>( this );
}
operator VkDirectDriverLoadingInfoLUNARG &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDirectDriverLoadingInfoLUNARG *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
void * const &,
VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG const &,
PFN_vkGetInstanceProcAddr const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, flags, pfnGetInstanceProcAddr );
}
#endif
bool operator==( DirectDriverLoadingInfoLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT
{
#if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
#else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnGetInstanceProcAddr == rhs.pfnGetInstanceProcAddr );
#endif
}
bool operator!=( DirectDriverLoadingInfoLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDirectDriverLoadingInfoLUNARG;
void * pNext = {};
VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG flags = {};
PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr = {};
};
template <>
struct CppType<StructureType, StructureType::eDirectDriverLoadingInfoLUNARG>
{
using Type = DirectDriverLoadingInfoLUNARG;
};
struct DirectDriverLoadingListLUNARG
{
using NativeType = VkDirectDriverLoadingListLUNARG;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDirectDriverLoadingListLUNARG;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DirectDriverLoadingListLUNARG(
VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG mode_ = VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG::eExclusive,
uint32_t driverCount_ = {},
const VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG * pDrivers_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, mode( mode_ )
, driverCount( driverCount_ )
, pDrivers( pDrivers_ )
{
}
VULKAN_HPP_CONSTEXPR DirectDriverLoadingListLUNARG( DirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DirectDriverLoadingListLUNARG( VkDirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT
: DirectDriverLoadingListLUNARG( *reinterpret_cast<DirectDriverLoadingListLUNARG const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
DirectDriverLoadingListLUNARG( VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG mode_,
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG> const & drivers_,
void * pNext_ = nullptr )
: pNext( pNext_ ), mode( mode_ ), driverCount( static_cast<uint32_t>( drivers_.size() ) ), pDrivers( drivers_.data() )
{
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
DirectDriverLoadingListLUNARG & operator=( DirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
DirectDriverLoadingListLUNARG & operator=( VkDirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setMode( VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG mode_ ) VULKAN_HPP_NOEXCEPT
{
mode = mode_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setDriverCount( uint32_t driverCount_ ) VULKAN_HPP_NOEXCEPT
{
driverCount = driverCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG &
setPDrivers( const VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG * pDrivers_ ) VULKAN_HPP_NOEXCEPT
{
pDrivers = pDrivers_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
DirectDriverLoadingListLUNARG & setDrivers(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG> const & drivers_ ) VULKAN_HPP_NOEXCEPT
{
driverCount = static_cast<uint32_t>( drivers_.size() );
pDrivers = drivers_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkDirectDriverLoadingListLUNARG const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDirectDriverLoadingListLUNARG *>( this );
}
operator VkDirectDriverLoadingListLUNARG &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDirectDriverLoadingListLUNARG *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
void * const &,
VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG const &,
uint32_t const &,
const VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, mode, driverCount, pDrivers );
}
#endif
bool operator==( DirectDriverLoadingListLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT
{
#if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
#else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( driverCount == rhs.driverCount ) && ( pDrivers == rhs.pDrivers );
#endif
}
bool operator!=( DirectDriverLoadingListLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDirectDriverLoadingListLUNARG;
void * pNext = {};
VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG mode = VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG::eExclusive;
uint32_t driverCount = {};
const VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG * pDrivers = {};
};
template <>
struct CppType<StructureType, StructureType::eDirectDriverLoadingListLUNARG>
{
using Type = DirectDriverLoadingListLUNARG;
};
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
struct DirectFBSurfaceCreateInfoEXT struct DirectFBSurfaceCreateInfoEXT
{ {
@ -38689,6 +38931,38 @@ namespace VULKAN_HPP_NAMESPACE
return *this; return *this;
} }
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setOffset( VULKAN_HPP_NAMESPACE::DeviceSize offset_ ) VULKAN_HPP_NOEXCEPT
{
offset = offset_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setSize( VULKAN_HPP_NAMESPACE::DeviceSize size_ ) VULKAN_HPP_NOEXCEPT
{
size = size_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setRowPitch( VULKAN_HPP_NAMESPACE::DeviceSize rowPitch_ ) VULKAN_HPP_NOEXCEPT
{
rowPitch = rowPitch_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setArrayPitch( VULKAN_HPP_NAMESPACE::DeviceSize arrayPitch_ ) VULKAN_HPP_NOEXCEPT
{
arrayPitch = arrayPitch_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setDepthPitch( VULKAN_HPP_NAMESPACE::DeviceSize depthPitch_ ) VULKAN_HPP_NOEXCEPT
{
depthPitch = depthPitch_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT
{ {
return *reinterpret_cast<const VkSubresourceLayout *>( this ); return *reinterpret_cast<const VkSubresourceLayout *>( this );
@ -63719,6 +63993,106 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
}; };
struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM
{
using NativeType = VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( VULKAN_HPP_NAMESPACE::Bool32 multiviewPerViewViewports_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, multiviewPerViewViewports( multiviewPerViewViewports_ )
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( *reinterpret_cast<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const *>( &rhs ) )
{
}
PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM &
operator=( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & operator=( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM &
setMultiviewPerViewViewports( VULKAN_HPP_NAMESPACE::Bool32 multiviewPerViewViewports_ ) VULKAN_HPP_NOEXCEPT
{
multiviewPerViewViewports = multiviewPerViewViewports_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>( this );
}
operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, multiviewPerViewViewports );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & ) const = default;
#else
bool operator==( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiviewPerViewViewports == rhs.multiviewPerViewViewports );
# endif
}
bool operator!=( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 multiviewPerViewViewports = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>
{
using Type = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
};
struct PhysicalDeviceMultiviewProperties struct PhysicalDeviceMultiviewProperties
{ {
using NativeType = VkPhysicalDeviceMultiviewProperties; using NativeType = VkPhysicalDeviceMultiviewProperties;
@ -98864,13 +99238,13 @@ namespace VULKAN_HPP_NAMESPACE
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoDecodeH265PictureInfoEXT( StdVideoDecodeH265PictureInfo * pStdPictureInfo_ = {}, VULKAN_HPP_CONSTEXPR VideoDecodeH265PictureInfoEXT( StdVideoDecodeH265PictureInfo * pStdPictureInfo_ = {},
uint32_t sliceCount_ = {}, uint32_t sliceSegmentCount_ = {},
const uint32_t * pSliceOffsets_ = {}, const uint32_t * pSliceSegmentOffsets_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ ) : pNext( pNext_ )
, pStdPictureInfo( pStdPictureInfo_ ) , pStdPictureInfo( pStdPictureInfo_ )
, sliceCount( sliceCount_ ) , sliceSegmentCount( sliceSegmentCount_ )
, pSliceOffsets( pSliceOffsets_ ) , pSliceSegmentOffsets( pSliceSegmentOffsets_ )
{ {
} }
@ -98883,9 +99257,12 @@ namespace VULKAN_HPP_NAMESPACE
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
VideoDecodeH265PictureInfoEXT( StdVideoDecodeH265PictureInfo * pStdPictureInfo_, VideoDecodeH265PictureInfoEXT( StdVideoDecodeH265PictureInfo * pStdPictureInfo_,
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & sliceOffsets_, VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & sliceSegmentOffsets_,
const void * pNext_ = nullptr ) const void * pNext_ = nullptr )
: pNext( pNext_ ), pStdPictureInfo( pStdPictureInfo_ ), sliceCount( static_cast<uint32_t>( sliceOffsets_.size() ) ), pSliceOffsets( sliceOffsets_.data() ) : pNext( pNext_ )
, pStdPictureInfo( pStdPictureInfo_ )
, sliceSegmentCount( static_cast<uint32_t>( sliceSegmentOffsets_.size() ) )
, pSliceSegmentOffsets( sliceSegmentOffsets_.data() )
{ {
} }
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -98912,23 +99289,24 @@ namespace VULKAN_HPP_NAMESPACE
return *this; return *this;
} }
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoEXT & setSliceCount( uint32_t sliceCount_ ) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoEXT & setSliceSegmentCount( uint32_t sliceSegmentCount_ ) VULKAN_HPP_NOEXCEPT
{ {
sliceCount = sliceCount_; sliceSegmentCount = sliceSegmentCount_;
return *this; return *this;
} }
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoEXT & setPSliceOffsets( const uint32_t * pSliceOffsets_ ) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoEXT & setPSliceSegmentOffsets( const uint32_t * pSliceSegmentOffsets_ ) VULKAN_HPP_NOEXCEPT
{ {
pSliceOffsets = pSliceOffsets_; pSliceSegmentOffsets = pSliceSegmentOffsets_;
return *this; return *this;
} }
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
VideoDecodeH265PictureInfoEXT & setSliceOffsets( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & sliceOffsets_ ) VULKAN_HPP_NOEXCEPT VideoDecodeH265PictureInfoEXT &
setSliceSegmentOffsets( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & sliceSegmentOffsets_ ) VULKAN_HPP_NOEXCEPT
{ {
sliceCount = static_cast<uint32_t>( sliceOffsets_.size() ); sliceSegmentCount = static_cast<uint32_t>( sliceSegmentOffsets_.size() );
pSliceOffsets = sliceOffsets_.data(); pSliceSegmentOffsets = sliceSegmentOffsets_.data();
return *this; return *this;
} }
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -98956,7 +99334,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif # endif
reflect() const VULKAN_HPP_NOEXCEPT reflect() const VULKAN_HPP_NOEXCEPT
{ {
return std::tie( sType, pNext, pStdPictureInfo, sliceCount, pSliceOffsets ); return std::tie( sType, pNext, pStdPictureInfo, sliceSegmentCount, pSliceSegmentOffsets );
} }
# endif # endif
@ -98968,8 +99346,8 @@ namespace VULKAN_HPP_NAMESPACE
# if defined( VULKAN_HPP_USE_REFLECT ) # if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect(); return this->reflect() == rhs.reflect();
# else # else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( sliceCount == rhs.sliceCount ) && return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( sliceSegmentCount == rhs.sliceSegmentCount ) &&
( pSliceOffsets == rhs.pSliceOffsets ); ( pSliceSegmentOffsets == rhs.pSliceSegmentOffsets );
# endif # endif
} }
@ -98983,8 +99361,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeH265PictureInfoEXT; VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeH265PictureInfoEXT;
const void * pNext = {}; const void * pNext = {};
StdVideoDecodeH265PictureInfo * pStdPictureInfo = {}; StdVideoDecodeH265PictureInfo * pStdPictureInfo = {};
uint32_t sliceCount = {}; uint32_t sliceSegmentCount = {};
const uint32_t * pSliceOffsets = {}; const uint32_t * pSliceSegmentOffsets = {};
}; };
template <> template <>

28
vulkan/vulkan_to_string.hpp
View File

@ -18,6 +18,7 @@
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
//========================== //==========================
//=== BITMASKs to_string === //=== BITMASKs to_string ===
//========================== //==========================
@ -3125,6 +3126,13 @@ namespace VULKAN_HPP_NAMESPACE
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
//=== VK_LUNARG_direct_driver_loading ===
VULKAN_HPP_INLINE std::string to_string( DirectDriverLoadingFlagsLUNARG )
{
return "{}";
}
//=== VK_NV_optical_flow === //=== VK_NV_optical_flow ===
VULKAN_HPP_INLINE std::string to_string( OpticalFlowUsageFlagsNV value ) VULKAN_HPP_INLINE std::string to_string( OpticalFlowUsageFlagsNV value )
@ -4040,6 +4048,8 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eRenderPassCreationControlEXT: return "RenderPassCreationControlEXT"; case StructureType::eRenderPassCreationControlEXT: return "RenderPassCreationControlEXT";
case StructureType::eRenderPassCreationFeedbackCreateInfoEXT: return "RenderPassCreationFeedbackCreateInfoEXT"; case StructureType::eRenderPassCreationFeedbackCreateInfoEXT: return "RenderPassCreationFeedbackCreateInfoEXT";
case StructureType::eRenderPassSubpassFeedbackCreateInfoEXT: return "RenderPassSubpassFeedbackCreateInfoEXT"; case StructureType::eRenderPassSubpassFeedbackCreateInfoEXT: return "RenderPassSubpassFeedbackCreateInfoEXT";
case StructureType::eDirectDriverLoadingInfoLUNARG: return "DirectDriverLoadingInfoLUNARG";
case StructureType::eDirectDriverLoadingListLUNARG: return "DirectDriverLoadingListLUNARG";
case StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT: return "PhysicalDeviceShaderModuleIdentifierFeaturesEXT"; case StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT: return "PhysicalDeviceShaderModuleIdentifierFeaturesEXT";
case StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT: return "PhysicalDeviceShaderModuleIdentifierPropertiesEXT"; case StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT: return "PhysicalDeviceShaderModuleIdentifierPropertiesEXT";
case StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT: return "PipelineShaderStageModuleIdentifierCreateInfoEXT"; case StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT: return "PipelineShaderStageModuleIdentifierCreateInfoEXT";
@ -4058,6 +4068,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eTilePropertiesQCOM: return "TilePropertiesQCOM"; case StructureType::eTilePropertiesQCOM: return "TilePropertiesQCOM";
case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC: return "PhysicalDeviceAmigoProfilingFeaturesSEC"; case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC: return "PhysicalDeviceAmigoProfilingFeaturesSEC";
case StructureType::eAmigoProfilingSubmitInfoSEC: return "AmigoProfilingSubmitInfoSEC"; case StructureType::eAmigoProfilingSubmitInfoSEC: return "AmigoProfilingSubmitInfoSEC";
case StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM: return "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM";
case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV: return "PhysicalDeviceRayTracingInvocationReorderFeaturesNV"; case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV: return "PhysicalDeviceRayTracingInvocationReorderFeaturesNV";
case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV: return "PhysicalDeviceRayTracingInvocationReorderPropertiesNV"; case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV: return "PhysicalDeviceRayTracingInvocationReorderPropertiesNV";
case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT: return "PhysicalDeviceMutableDescriptorTypeFeaturesEXT"; case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT: return "PhysicalDeviceMutableDescriptorTypeFeaturesEXT";
@ -8153,6 +8164,23 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
//=== VK_LUNARG_direct_driver_loading ===
VULKAN_HPP_INLINE std::string to_string( DirectDriverLoadingModeLUNARG value )
{
switch ( value )
{
case DirectDriverLoadingModeLUNARG::eExclusive: return "Exclusive";
case DirectDriverLoadingModeLUNARG::eInclusive: return "Inclusive";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( DirectDriverLoadingFlagBitsLUNARG )
{
return "(void)";
}
//=== VK_EXT_rasterization_order_attachment_access === //=== VK_EXT_rasterization_order_attachment_access ===
VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits value ) VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits value )