mirror of
https://github.com/KhronosGroup/Vulkan-Hpp.git
synced 2024-10-14 16:32:17 +00:00
Update Vulkan-Headers to v1.3.289 (#1912)
Co-authored-by: GitHub <noreply@github.com>
This commit is contained in:
parent
620cf05ac2
commit
630d8da8c6
@ -1 +1 @@
|
||||
Subproject commit 05fe2cc910a68c9ba5dac07db46ef78573acee72
|
||||
Subproject commit 190d2cb24e90e5bf2bec0a75604a9b3586485b6d
|
@ -844,6 +844,9 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
|
||||
using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR;
|
||||
|
||||
//=========================
|
||||
//=== Index Type Traits ===
|
||||
//=========================
|
||||
@ -2506,6 +2509,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion;
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRMaintenance7ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRMaintenance7SpecVersion;
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion;
|
||||
@ -4369,6 +4376,13 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_KHR_shader_relaxed_extended_instruction ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR;
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
|
||||
|
||||
|
@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
|
||||
# include <span>
|
||||
#endif
|
||||
|
||||
static_assert( VK_HEADER_VERSION == 288, "Wrong VK_HEADER_VERSION!" );
|
||||
static_assert( VK_HEADER_VERSION == 289, "Wrong VK_HEADER_VERSION!" );
|
||||
|
||||
// <tuple> includes <sys/sysmacros.h> through some other header
|
||||
// this results in major(x) being resolved to gnu_dev_major(x)
|
||||
@ -8639,6 +8639,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION;
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7ExtensionName = VK_KHR_MAINTENANCE_7_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7SpecVersion = VK_KHR_MAINTENANCE_7_SPEC_VERSION;
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION;
|
||||
@ -16670,6 +16674,52 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
};
|
||||
};
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceMaintenance7FeaturesKHR, PhysicalDeviceFeatures2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceMaintenance7FeaturesKHR, DeviceCreateInfo>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceMaintenance7PropertiesKHR, PhysicalDeviceProperties2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceLayeredApiPropertiesListKHR, PhysicalDeviceProperties2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceLayeredApiVulkanPropertiesKHR, PhysicalDeviceLayeredApiPropertiesKHR>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, PhysicalDeviceFeatures2>
|
||||
@ -16801,7 +16851,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
|
||||
}
|
||||
# elif defined( _WIN32 )
|
||||
m_library = ::LoadLibraryA( "vulkan-1.dll" );
|
||||
m_library = ::LoadLibraryA( "vulkan-1.dll" );
|
||||
# else
|
||||
# error unsupported platform
|
||||
# endif
|
||||
|
@ -1419,6 +1419,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV,
|
||||
ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV,
|
||||
ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR,
|
||||
ePhysicalDeviceMaintenance7FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR,
|
||||
ePhysicalDeviceMaintenance7PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR,
|
||||
ePhysicalDeviceLayeredApiPropertiesListKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR,
|
||||
ePhysicalDeviceLayeredApiPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR,
|
||||
ePhysicalDeviceLayeredApiVulkanPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR,
|
||||
ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV,
|
||||
ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT,
|
||||
ePhysicalDeviceRayTracingValidationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV,
|
||||
@ -3640,6 +3645,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
eInline = VK_SUBPASS_CONTENTS_INLINE,
|
||||
eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
|
||||
eInlineAndSecondaryCommandBuffersKHR = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR,
|
||||
eInlineAndSecondaryCommandBuffersEXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT
|
||||
};
|
||||
|
||||
@ -4329,8 +4335,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
eContentsSecondaryCommandBuffers = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,
|
||||
eSuspending = VK_RENDERING_SUSPENDING_BIT,
|
||||
eResuming = VK_RENDERING_RESUMING_BIT,
|
||||
eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT,
|
||||
eEnableLegacyDitheringEXT = VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT
|
||||
eEnableLegacyDitheringEXT = VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT,
|
||||
eContentsInlineKHR = VK_RENDERING_CONTENTS_INLINE_BIT_KHR,
|
||||
eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT
|
||||
};
|
||||
using RenderingFlagBitsKHR = RenderingFlagBits;
|
||||
|
||||
@ -4342,8 +4349,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = RenderingFlagBits::eContentsSecondaryCommandBuffers | RenderingFlagBits::eSuspending |
|
||||
RenderingFlagBits::eResuming | RenderingFlagBits::eContentsInlineEXT |
|
||||
RenderingFlagBits::eEnableLegacyDitheringEXT;
|
||||
RenderingFlagBits::eResuming | RenderingFlagBits::eEnableLegacyDitheringEXT |
|
||||
RenderingFlagBits::eContentsInlineKHR;
|
||||
};
|
||||
|
||||
enum class FormatFeatureFlagBits2 : VkFormatFeatureFlags2
|
||||
@ -7304,6 +7311,17 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
};
|
||||
using TimeDomainEXT = TimeDomainKHR;
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
|
||||
enum class PhysicalDeviceLayeredApiKHR
|
||||
{
|
||||
eVulkan = VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR,
|
||||
eD3D12 = VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR,
|
||||
eMetal = VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR,
|
||||
eOpengl = VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR,
|
||||
eOpengles = VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR
|
||||
};
|
||||
|
||||
//===========================================================
|
||||
//=== Mapping from ObjectType to DebugReportObjectTypeEXT ===
|
||||
//===========================================================
|
||||
|
@ -437,6 +437,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_NV_descriptor_pool_overallocation",
|
||||
"VK_NV_raw_access_chains",
|
||||
"VK_KHR_shader_relaxed_extended_instruction",
|
||||
"VK_KHR_maintenance7",
|
||||
"VK_NV_shader_atomic_float16_vector",
|
||||
"VK_EXT_shader_replicated_composites",
|
||||
"VK_NV_ray_tracing_validation",
|
||||
@ -2316,6 +2317,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_MESA_image_alignment_control",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
@ -3085,9 +3087,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
|
||||
( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
|
||||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_raw_access_chains" ) ||
|
||||
( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
|
||||
( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
|
||||
( extension == "VK_MESA_image_alignment_control" );
|
||||
( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_KHR_maintenance7" ) ||
|
||||
( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
|
||||
( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_MESA_image_alignment_control" );
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
|
||||
|
@ -1830,6 +1830,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_KHR_shader_relaxed_extended_instruction ===
|
||||
struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
struct PhysicalDeviceMaintenance7FeaturesKHR;
|
||||
struct PhysicalDeviceMaintenance7PropertiesKHR;
|
||||
struct PhysicalDeviceLayeredApiPropertiesListKHR;
|
||||
struct PhysicalDeviceLayeredApiPropertiesKHR;
|
||||
struct PhysicalDeviceLayeredApiVulkanPropertiesKHR;
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
|
||||
|
||||
|
@ -9426,57 +9426,36 @@ namespace std
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR const & physicalDeviceLayeredApiPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.vendorID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.layeredAPI );
|
||||
for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
|
||||
{
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceName[i] );
|
||||
}
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR const & physicalDeviceLayeredApiPropertiesListKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT>
|
||||
{
|
||||
std::size_t operator()(
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & physicalDeviceLegacyVertexAttributesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.legacyVertexAttributes );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & physicalDeviceLegacyVertexAttributesPropertiesEXT )
|
||||
const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.nativeUnalignedPerformance );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.layeredApiCount );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pLayeredApis );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
@ -9615,6 +9594,129 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType );
|
||||
for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
|
||||
{
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] );
|
||||
}
|
||||
for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
|
||||
{
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] );
|
||||
}
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR const & physicalDeviceLayeredApiVulkanPropertiesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.properties );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT>
|
||||
{
|
||||
std::size_t operator()(
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & physicalDeviceLegacyVertexAttributesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.legacyVertexAttributes );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & physicalDeviceLegacyVertexAttributesPropertiesEXT )
|
||||
const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.nativeUnalignedPerformance );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>
|
||||
{
|
||||
@ -9765,6 +9867,41 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR const & physicalDeviceMaintenance7FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.maintenance7 );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR const & physicalDeviceMaintenance7PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.robustFragmentShadingRateAttachmentAccess );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.separateDepthStencilAttachmentAccess );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalUniformBuffersDynamic );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalStorageBuffersDynamic );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalBuffersDynamic );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT>
|
||||
{
|
||||
@ -10567,59 +10704,6 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType );
|
||||
for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
|
||||
{
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] );
|
||||
}
|
||||
for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
|
||||
{
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] );
|
||||
}
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
|
||||
{
|
||||
|
@ -7571,6 +7571,44 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>::value,
|
||||
"PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance7FeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR>::value,
|
||||
"PhysicalDeviceMaintenance7FeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR ) == sizeof( VkPhysicalDeviceMaintenance7PropertiesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR>::value,
|
||||
"PhysicalDeviceMaintenance7PropertiesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR ) == sizeof( VkPhysicalDeviceLayeredApiPropertiesListKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR>::value,
|
||||
"PhysicalDeviceLayeredApiPropertiesListKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR ) == sizeof( VkPhysicalDeviceLayeredApiPropertiesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR>::value,
|
||||
"PhysicalDeviceLayeredApiPropertiesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceLayeredApiVulkanPropertiesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR>::value,
|
||||
"PhysicalDeviceLayeredApiVulkanPropertiesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) ==
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -1747,10 +1747,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "Suspending | ";
|
||||
if ( value & RenderingFlagBits::eResuming )
|
||||
result += "Resuming | ";
|
||||
if ( value & RenderingFlagBits::eContentsInlineEXT )
|
||||
result += "ContentsInlineEXT | ";
|
||||
if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT )
|
||||
result += "EnableLegacyDitheringEXT | ";
|
||||
if ( value & RenderingFlagBits::eContentsInlineKHR )
|
||||
result += "ContentsInlineKHR | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@ -4553,6 +4553,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR: return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceMaintenance7FeaturesKHR: return "PhysicalDeviceMaintenance7FeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceMaintenance7PropertiesKHR: return "PhysicalDeviceMaintenance7PropertiesKHR";
|
||||
case StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR: return "PhysicalDeviceLayeredApiPropertiesListKHR";
|
||||
case StructureType::ePhysicalDeviceLayeredApiPropertiesKHR: return "PhysicalDeviceLayeredApiPropertiesKHR";
|
||||
case StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR: return "PhysicalDeviceLayeredApiVulkanPropertiesKHR";
|
||||
case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT: return "PhysicalDeviceShaderReplicatedCompositesFeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV: return "PhysicalDeviceRayTracingValidationFeaturesNV";
|
||||
@ -6250,7 +6255,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
case SubpassContents::eInline: return "Inline";
|
||||
case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers";
|
||||
case SubpassContents::eInlineAndSecondaryCommandBuffersEXT: return "InlineAndSecondaryCommandBuffersEXT";
|
||||
case SubpassContents::eInlineAndSecondaryCommandBuffersKHR: return "InlineAndSecondaryCommandBuffersKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -6734,8 +6739,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case RenderingFlagBits::eContentsSecondaryCommandBuffers: return "ContentsSecondaryCommandBuffers";
|
||||
case RenderingFlagBits::eSuspending: return "Suspending";
|
||||
case RenderingFlagBits::eResuming: return "Resuming";
|
||||
case RenderingFlagBits::eContentsInlineEXT: return "ContentsInlineEXT";
|
||||
case RenderingFlagBits::eEnableLegacyDitheringEXT: return "EnableLegacyDitheringEXT";
|
||||
case RenderingFlagBits::eContentsInlineKHR: return "ContentsInlineKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -9081,5 +9086,20 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceLayeredApiKHR value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PhysicalDeviceLayeredApiKHR::eVulkan: return "Vulkan";
|
||||
case PhysicalDeviceLayeredApiKHR::eD3D12: return "D3D12";
|
||||
case PhysicalDeviceLayeredApiKHR::eMetal: return "Metal";
|
||||
case PhysicalDeviceLayeredApiKHR::eOpengl: return "Opengl";
|
||||
case PhysicalDeviceLayeredApiKHR::eOpengles: return "Opengles";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
#endif
|
||||
|
@ -388,6 +388,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_blend_operation_advanced ===
|
||||
using VULKAN_HPP_NAMESPACE::BlendOverlapEXT;
|
||||
|
||||
//=== VK_KHR_global_priority ===
|
||||
using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT;
|
||||
using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
using VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR;
|
||||
|
||||
@ -409,6 +413,14 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::SciSyncPrimitiveTypeNV;
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT;
|
||||
using VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
|
||||
using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
|
||||
|
||||
//=========================
|
||||
//=== Index Type Traits ===
|
||||
//=========================
|
||||
@ -449,6 +461,7 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::MemoryMapFailedError;
|
||||
using VULKAN_HPP_NAMESPACE::NativeWindowInUseKHRError;
|
||||
using VULKAN_HPP_NAMESPACE::NoPipelineMatchError;
|
||||
using VULKAN_HPP_NAMESPACE::NotPermittedKHRError;
|
||||
using VULKAN_HPP_NAMESPACE::OutOfDateKHRError;
|
||||
using VULKAN_HPP_NAMESPACE::OutOfDeviceMemoryError;
|
||||
using VULKAN_HPP_NAMESPACE::OutOfHostMemoryError;
|
||||
@ -629,10 +642,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::EXTFilterCubicExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTFilterCubicSpecVersion;
|
||||
|
||||
//=== VK_EXT_global_priority ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTGlobalPrioritySpecVersion;
|
||||
|
||||
//=== VK_EXT_external_memory_host ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTExternalMemoryHostExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTExternalMemoryHostSpecVersion;
|
||||
@ -641,13 +650,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderClockExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderClockSpecVersion;
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTCalibratedTimestampsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTCalibratedTimestampsSpecVersion;
|
||||
|
||||
//=== VK_EXT_vertex_attribute_divisor ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeDivisorExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeDivisorSpecVersion;
|
||||
//=== VK_KHR_global_priority ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRGlobalPriorityExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRGlobalPrioritySpecVersion;
|
||||
using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeKHR;
|
||||
|
||||
//=== VK_KHR_swapchain_mutable_format ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRSwapchainMutableFormatExtensionName;
|
||||
@ -749,6 +755,12 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::EXT4444FormatsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXT4444FormatsSpecVersion;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
using VULKAN_HPP_NAMESPACE::NVAcquireWinrtDisplayExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVAcquireWinrtDisplaySpecVersion;
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
//=== VK_EXT_vertex_input_dynamic_state ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTVertexInputDynamicStateExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTVertexInputDynamicStateSpecVersion;
|
||||
@ -783,12 +795,28 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::NVExternalSciSync2SpecVersion;
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_vertex_attribute_divisor ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorSpecVersion;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferSpecVersion;
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8SpecVersion;
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRLineRasterizationExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRLineRasterizationSpecVersion;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsSpecVersion;
|
||||
|
||||
//========================
|
||||
//=== CONSTEXPR VALUEs ===
|
||||
//========================
|
||||
@ -1411,8 +1439,13 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_KHR_shader_clock ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR;
|
||||
|
||||
//=== VK_EXT_vertex_attribute_divisor ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
|
||||
//=== VK_KHR_global_priority ===
|
||||
using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR;
|
||||
|
||||
//=== VK_EXT_pci_bus_info ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT;
|
||||
@ -1519,6 +1552,15 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolCreateInfoNV;
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_vertex_attribute_divisor ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT;
|
||||
using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
using VULKAN_HPP_NAMESPACE::ExternalFormatQNX;
|
||||
@ -1528,6 +1570,22 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX;
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR;
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR;
|
||||
|
||||
//===============
|
||||
//=== HANDLEs ===
|
||||
//===============
|
||||
|
@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
|
||||
# include <span>
|
||||
#endif
|
||||
|
||||
static_assert( VK_HEADER_VERSION == 14, "Wrong VK_HEADER_VERSION!" );
|
||||
static_assert( VK_HEADER_VERSION == 15, "Wrong VK_HEADER_VERSION!" );
|
||||
|
||||
// <tuple> includes <sys/sysmacros.h> through some other header
|
||||
// this results in major(x) being resolved to gnu_dev_major(x)
|
||||
@ -2774,24 +2774,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
|
||||
}
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
|
||||
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice,
|
||||
uint32_t * pTimeDomainCount,
|
||||
VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
|
||||
}
|
||||
|
||||
VkResult vkGetCalibratedTimestampsEXT( VkDevice device,
|
||||
uint32_t timestampCount,
|
||||
const VkCalibratedTimestampInfoKHR * pTimestampInfos,
|
||||
uint64_t * pTimestamps,
|
||||
uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
|
||||
}
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
|
||||
VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice,
|
||||
@ -2990,6 +2972,20 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
|
||||
}
|
||||
|
||||
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
|
||||
VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
|
||||
}
|
||||
|
||||
VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
|
||||
}
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
//=== VK_EXT_vertex_input_dynamic_state ===
|
||||
|
||||
void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer,
|
||||
@ -3121,6 +3117,31 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
return ::vkGetScreenBufferPropertiesQNX( device, buffer, pProperties );
|
||||
}
|
||||
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
void vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ::vkCmdSetLineStippleKHR( commandBuffer, lineStippleFactor, lineStipplePattern );
|
||||
}
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice physicalDevice,
|
||||
uint32_t * pTimeDomainCount,
|
||||
VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ::vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( physicalDevice, pTimeDomainCount, pTimeDomains );
|
||||
}
|
||||
|
||||
VkResult vkGetCalibratedTimestampsKHR( VkDevice device,
|
||||
uint32_t timestampCount,
|
||||
const VkCalibratedTimestampInfoKHR * pTimestampInfos,
|
||||
uint64_t * pTimestamps,
|
||||
uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ::vkGetCalibratedTimestampsKHR( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
|
||||
}
|
||||
};
|
||||
|
||||
inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
|
||||
@ -3659,6 +3680,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
};
|
||||
|
||||
class NotPermittedKHRError : public SystemError
|
||||
{
|
||||
public:
|
||||
NotPermittedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
|
||||
|
||||
NotPermittedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
[[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
|
||||
@ -3690,6 +3719,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
|
||||
case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
|
||||
case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
|
||||
case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError( message );
|
||||
default: throw SystemError( make_error_code( result ), message );
|
||||
}
|
||||
}
|
||||
@ -3912,6 +3942,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_queue_family_foreign ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyForeignEXT = VK_QUEUE_FAMILY_FOREIGN_EXT;
|
||||
|
||||
//=== VK_KHR_global_priority ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeKHR = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR;
|
||||
|
||||
//========================
|
||||
//=== CONSTEXPR VALUEs ===
|
||||
//========================
|
||||
@ -4126,12 +4159,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicExtensionName = VK_EXT_FILTER_CUBIC_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicSpecVersion = VK_EXT_FILTER_CUBIC_SPEC_VERSION;
|
||||
|
||||
//=== VK_EXT_global_priority ===
|
||||
VULKAN_HPP_DEPRECATED( "The VK_EXT_global_priority extension has been promoted to VK_KHR_global_priority." )
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityExtensionName = VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME;
|
||||
VULKAN_HPP_DEPRECATED( "The VK_EXT_global_priority extension has been promoted to VK_KHR_global_priority." )
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPrioritySpecVersion = VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION;
|
||||
|
||||
//=== VK_EXT_external_memory_host ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostExtensionName = VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostSpecVersion = VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION;
|
||||
@ -4140,17 +4167,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockExtensionName = VK_KHR_SHADER_CLOCK_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockSpecVersion = VK_KHR_SHADER_CLOCK_SPEC_VERSION;
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
VULKAN_HPP_DEPRECATED( "The VK_EXT_calibrated_timestamps extension has been promoted to VK_KHR_calibrated_timestamps." )
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsExtensionName = VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
|
||||
VULKAN_HPP_DEPRECATED( "The VK_EXT_calibrated_timestamps extension has been promoted to VK_KHR_calibrated_timestamps." )
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsSpecVersion = VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION;
|
||||
|
||||
//=== VK_EXT_vertex_attribute_divisor ===
|
||||
VULKAN_HPP_DEPRECATED( "The VK_EXT_vertex_attribute_divisor extension has been promoted to VK_KHR_vertex_attribute_divisor." )
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorExtensionName = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
|
||||
VULKAN_HPP_DEPRECATED( "The VK_EXT_vertex_attribute_divisor extension has been promoted to VK_KHR_vertex_attribute_divisor." )
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION;
|
||||
//=== VK_KHR_global_priority ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPriorityExtensionName = VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPrioritySpecVersion = VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION;
|
||||
|
||||
//=== VK_KHR_swapchain_mutable_format ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatExtensionName = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME;
|
||||
@ -4278,6 +4297,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_DEPRECATED( "The VK_EXT_4444_formats extension has been promoted to core in version 1.3." )
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsSpecVersion = VK_EXT_4444_FORMATS_SPEC_VERSION;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplayExtensionName = VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplaySpecVersion = VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION;
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
//=== VK_EXT_vertex_input_dynamic_state ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateExtensionName = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateSpecVersion = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION;
|
||||
@ -4316,12 +4341,28 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalSciSync2SpecVersion = VK_NV_EXTERNAL_SCI_SYNC_2_SPEC_VERSION;
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_vertex_attribute_divisor ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorExtensionName = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorSpecVersion = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferExtensionName = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferSpecVersion = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION;
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8ExtensionName = VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8SpecVersion = VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION;
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationExtensionName = VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationSpecVersion = VK_KHR_LINE_RASTERIZATION_SPEC_VERSION;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsExtensionName = VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
|
||||
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsSpecVersion = VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION;
|
||||
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
// clang-format off
|
||||
@ -6306,9 +6347,36 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
};
|
||||
};
|
||||
|
||||
//=== VK_EXT_vertex_attribute_divisor ===
|
||||
//=== VK_KHR_global_priority ===
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceProperties2>
|
||||
struct StructExtends<DeviceQueueGlobalPriorityCreateInfoKHR, DeviceQueueCreateInfo>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, PhysicalDeviceFeatures2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, DeviceCreateInfo>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<QueueFamilyGlobalPriorityPropertiesKHR, QueueFamilyProperties2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
@ -6839,6 +6907,43 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
};
|
||||
# endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_vertex_attribute_divisor ===
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesKHR, PhysicalDeviceProperties2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PipelineVertexInputDivisorStateCreateInfoKHR, PipelineVertexInputStateCreateInfo>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesKHR, PhysicalDeviceFeatures2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesKHR, DeviceCreateInfo>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
# if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
template <>
|
||||
@ -6896,6 +7001,62 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
};
|
||||
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesKHR, PhysicalDeviceFeatures2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesKHR, DeviceCreateInfo>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceLineRasterizationFeaturesKHR, PhysicalDeviceFeatures2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceLineRasterizationFeaturesKHR, DeviceCreateInfo>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PhysicalDeviceLineRasterizationPropertiesKHR, PhysicalDeviceProperties2>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct StructExtends<PipelineRasterizationLineStateCreateInfoKHR, PipelineRasterizationStateCreateInfo>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = true
|
||||
};
|
||||
};
|
||||
|
||||
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
|
||||
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
|
||||
@ -6933,7 +7094,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
|
||||
}
|
||||
# elif defined( _WIN32 )
|
||||
m_library = ::LoadLibraryA( "vulkan-1.dll" );
|
||||
m_library = ::LoadLibraryA( "vulkan-1.dll" );
|
||||
# else
|
||||
# error unsupported platform
|
||||
# endif
|
||||
@ -7323,10 +7484,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_external_memory_host ===
|
||||
PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
|
||||
PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
|
||||
PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0;
|
||||
@ -7373,6 +7530,15 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0;
|
||||
PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
|
||||
PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
|
||||
#else
|
||||
PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0;
|
||||
PFN_dummy vkGetWinrtDisplayNV_placeholder = 0;
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
//=== VK_EXT_vertex_input_dynamic_state ===
|
||||
PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0;
|
||||
|
||||
@ -7430,6 +7596,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0;
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0;
|
||||
PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0;
|
||||
|
||||
public:
|
||||
DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
|
||||
DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
|
||||
@ -7840,15 +8013,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_external_memory_host ===
|
||||
vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) );
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
vkGetPhysicalDeviceCalibrateableTimeDomainsEXT =
|
||||
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
|
||||
if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR )
|
||||
vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
|
||||
vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
|
||||
if ( !vkGetCalibratedTimestampsKHR )
|
||||
vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
vkGetPhysicalDeviceFragmentShadingRatesKHR =
|
||||
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
|
||||
@ -7947,6 +8111,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
if ( !vkCmdResolveImage2 )
|
||||
vkCmdResolveImage2 = vkCmdResolveImage2KHR;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
|
||||
vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
//=== VK_EXT_vertex_input_dynamic_state ===
|
||||
vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) );
|
||||
|
||||
@ -7996,6 +8166,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetInstanceProcAddr( instance, "vkGetScreenBufferPropertiesQNX" ) );
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleKHR" ) );
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
vkGetPhysicalDeviceCalibrateableTimeDomainsKHR =
|
||||
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) );
|
||||
vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsKHR" ) );
|
||||
}
|
||||
|
||||
void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
|
||||
@ -8254,11 +8432,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_external_memory_host ===
|
||||
vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
|
||||
if ( !vkGetCalibratedTimestampsKHR )
|
||||
vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
|
||||
|
||||
@ -8393,6 +8566,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) );
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) );
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) );
|
||||
}
|
||||
|
||||
template <typename DynamicLoader>
|
||||
|
@ -256,7 +256,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
|
||||
eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
|
||||
eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
|
||||
eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT
|
||||
eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT,
|
||||
eErrorNotPermittedKHR = VK_ERROR_NOT_PERMITTED_KHR
|
||||
};
|
||||
|
||||
enum class StructureType
|
||||
@ -581,7 +582,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
|
||||
ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
|
||||
ePhysicalDeviceShaderClockFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
|
||||
ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
|
||||
eDeviceQueueGlobalPriorityCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR,
|
||||
ePhysicalDeviceGlobalPriorityQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR,
|
||||
eQueueFamilyGlobalPriorityPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR,
|
||||
ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
|
||||
eFragmentShadingRateAttachmentInfoKHR = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
|
||||
ePipelineFragmentShadingRateStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR,
|
||||
@ -636,13 +639,25 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
ePhysicalDeviceExternalSciSync2FeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV,
|
||||
eDeviceSemaphoreSciSyncPoolReservationCreateInfoNV = VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV,
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
ePhysicalDeviceVertexAttributeDivisorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR,
|
||||
ePipelineVertexInputDivisorStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR,
|
||||
ePhysicalDeviceVertexAttributeDivisorFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR,
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
eScreenBufferPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX,
|
||||
eScreenBufferFormatPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX,
|
||||
eImportScreenBufferInfoQNX = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX,
|
||||
eExternalFormatQNX = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX,
|
||||
ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX
|
||||
ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
ePhysicalDeviceIndexTypeUint8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR,
|
||||
ePhysicalDeviceIndexTypeUint8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
|
||||
ePhysicalDeviceLineRasterizationFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR,
|
||||
ePhysicalDeviceLineRasterizationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
|
||||
ePipelineRasterizationLineStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR,
|
||||
ePipelineRasterizationLineStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
|
||||
ePhysicalDeviceLineRasterizationPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR,
|
||||
ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
|
||||
eCalibratedTimestampInfoKHR = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR
|
||||
};
|
||||
|
||||
enum class PipelineCacheHeaderVersion
|
||||
@ -1736,7 +1751,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
eVertexInputEXT = VK_DYNAMIC_STATE_VERTEX_INPUT_EXT,
|
||||
ePatchControlPointsEXT = VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT,
|
||||
eLogicOpEXT = VK_DYNAMIC_STATE_LOGIC_OP_EXT,
|
||||
eColorWriteEnableEXT = VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT
|
||||
eColorWriteEnableEXT = VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT,
|
||||
eLineStippleKHR = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR,
|
||||
eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT
|
||||
};
|
||||
|
||||
enum class FrontFace
|
||||
@ -2316,8 +2333,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
enum class IndexType
|
||||
{
|
||||
eUint16 = VK_INDEX_TYPE_UINT16,
|
||||
eUint32 = VK_INDEX_TYPE_UINT32
|
||||
eUint16 = VK_INDEX_TYPE_UINT16,
|
||||
eUint32 = VK_INDEX_TYPE_UINT32,
|
||||
eUint8KHR = VK_INDEX_TYPE_UINT8_KHR,
|
||||
eUint8EXT = VK_INDEX_TYPE_UINT8_EXT
|
||||
};
|
||||
|
||||
//=========================
|
||||
@ -3496,6 +3515,17 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
|
||||
};
|
||||
|
||||
//=== VK_KHR_global_priority ===
|
||||
|
||||
enum class QueueGlobalPriorityKHR
|
||||
{
|
||||
eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR,
|
||||
eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR,
|
||||
eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR,
|
||||
eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR
|
||||
};
|
||||
using QueueGlobalPriorityEXT = QueueGlobalPriorityKHR;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
|
||||
enum class FragmentShadingRateCombinerOpKHR
|
||||
@ -3577,6 +3607,28 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
};
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
enum class LineRasterizationModeKHR
|
||||
{
|
||||
eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR,
|
||||
eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR,
|
||||
eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR,
|
||||
eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR
|
||||
};
|
||||
using LineRasterizationModeEXT = LineRasterizationModeKHR;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
enum class TimeDomainKHR
|
||||
{
|
||||
eDevice = VK_TIME_DOMAIN_DEVICE_KHR,
|
||||
eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR,
|
||||
eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR,
|
||||
eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR
|
||||
};
|
||||
using TimeDomainEXT = TimeDomainKHR;
|
||||
|
||||
//===========================================================
|
||||
//=== Mapping from ObjectType to DebugReportObjectTypeEXT ===
|
||||
//===========================================================
|
||||
|
@ -79,11 +79,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_EXT_post_depth_coverage",
|
||||
"VK_EXT_image_drm_format_modifier",
|
||||
"VK_EXT_filter_cubic",
|
||||
"VK_EXT_global_priority",
|
||||
"VK_EXT_external_memory_host",
|
||||
"VK_KHR_shader_clock",
|
||||
"VK_EXT_calibrated_timestamps",
|
||||
"VK_EXT_vertex_attribute_divisor",
|
||||
"VK_KHR_global_priority",
|
||||
"VK_KHR_swapchain_mutable_format",
|
||||
"VK_EXT_pci_bus_info",
|
||||
"VK_KHR_shader_terminate_invocation",
|
||||
@ -107,6 +105,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_EXT_image_robustness",
|
||||
"VK_KHR_copy_commands2",
|
||||
"VK_EXT_4444_formats",
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
"VK_NV_acquire_winrt_display",
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
"VK_EXT_vertex_input_dynamic_state",
|
||||
#if defined( VK_USE_PLATFORM_SCI )
|
||||
"VK_NV_external_sci_sync",
|
||||
@ -117,9 +118,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#if defined( VK_USE_PLATFORM_SCI )
|
||||
"VK_NV_external_sci_sync2",
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
"VK_KHR_vertex_attribute_divisor",
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
"VK_QNX_external_memory_screen_buffer"
|
||||
"VK_QNX_external_memory_screen_buffer",
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
"VK_KHR_index_type_uint8",
|
||||
"VK_KHR_line_rasterization",
|
||||
"VK_KHR_calibrated_timestamps"
|
||||
};
|
||||
return deviceExtensions;
|
||||
}
|
||||
@ -314,13 +319,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_calibrated_timestamps",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_vertex_attribute_divisor",
|
||||
{ "VK_KHR_global_priority",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
@ -472,6 +471,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
{ "VK_NV_acquire_winrt_display",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_direct_mode_display",
|
||||
} } } } },
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
{ "VK_EXT_vertex_input_dynamic_state",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
@ -497,6 +503,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#if defined( VK_USE_PLATFORM_SCI )
|
||||
{ "VK_NV_external_sci_sync2", { { "VK_VERSION_1_1", { {} } } } },
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
{ "VK_KHR_vertex_attribute_divisor",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
{ "VK_QNX_external_memory_screen_buffer",
|
||||
{ { "VK_VERSION_1_0",
|
||||
@ -508,8 +520,26 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_EXT_queue_family_foreign",
|
||||
} } } } }
|
||||
} } } } },
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
{ "VK_KHR_index_type_uint8",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_KHR_line_rasterization",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_KHR_calibrated_timestamps",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } }
|
||||
};
|
||||
auto depIt = dependencies.find( extension );
|
||||
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
|
||||
@ -524,9 +554,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_INLINE std::map<std::string, std::string> const & getPromotedExtensions()
|
||||
{
|
||||
static std::map<std::string, std::string> promotedExtensions = { { "VK_EXT_texture_compression_astc_hdr", "VK_VERSION_1_3" },
|
||||
{ "VK_EXT_global_priority", "VK_KHR_global_priority" },
|
||||
{ "VK_EXT_calibrated_timestamps", "VK_KHR_calibrated_timestamps" },
|
||||
{ "VK_EXT_vertex_attribute_divisor", "VK_KHR_vertex_attribute_divisor" },
|
||||
{ "VK_KHR_shader_terminate_invocation", "VK_VERSION_1_3" },
|
||||
{ "VK_EXT_subgroup_size_control", "VK_VERSION_1_3" },
|
||||
{ "VK_EXT_line_rasterization", "VK_KHR_line_rasterization" },
|
||||
@ -574,18 +601,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
return "VK_VERSION_1_3";
|
||||
}
|
||||
if ( extension == "VK_EXT_global_priority" )
|
||||
{
|
||||
return "VK_KHR_global_priority";
|
||||
}
|
||||
if ( extension == "VK_EXT_calibrated_timestamps" )
|
||||
{
|
||||
return "VK_KHR_calibrated_timestamps";
|
||||
}
|
||||
if ( extension == "VK_EXT_vertex_attribute_divisor" )
|
||||
{
|
||||
return "VK_KHR_vertex_attribute_divisor";
|
||||
}
|
||||
if ( extension == "VK_KHR_shader_terminate_invocation" )
|
||||
{
|
||||
return "VK_VERSION_1_3";
|
||||
@ -662,18 +677,20 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
( extension == "VK_EXT_external_memory_dma_buf" ) || ( extension == "VK_EXT_queue_family_foreign" ) ||
|
||||
( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_EXT_sample_locations" ) ||
|
||||
( extension == "VK_EXT_blend_operation_advanced" ) || ( extension == "VK_EXT_post_depth_coverage" ) ||
|
||||
( extension == "VK_EXT_image_drm_format_modifier" ) || ( extension == "VK_EXT_filter_cubic" ) || ( extension == "VK_EXT_global_priority" ) ||
|
||||
( extension == "VK_EXT_external_memory_host" ) || ( extension == "VK_KHR_shader_clock" ) || ( extension == "VK_EXT_calibrated_timestamps" ) ||
|
||||
( extension == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_KHR_swapchain_mutable_format" ) || ( extension == "VK_EXT_pci_bus_info" ) ||
|
||||
( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_subgroup_size_control" ) ||
|
||||
( extension == "VK_EXT_image_drm_format_modifier" ) || ( extension == "VK_EXT_filter_cubic" ) || ( extension == "VK_EXT_external_memory_host" ) ||
|
||||
( extension == "VK_KHR_shader_clock" ) || ( extension == "VK_KHR_global_priority" ) || ( extension == "VK_KHR_swapchain_mutable_format" ) ||
|
||||
( extension == "VK_EXT_pci_bus_info" ) || ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_subgroup_size_control" ) ||
|
||||
( extension == "VK_KHR_fragment_shading_rate" ) || ( extension == "VK_EXT_shader_image_atomic_int64" ) || ( extension == "VK_EXT_memory_budget" ) ||
|
||||
( extension == "VK_EXT_fragment_shader_interlock" ) || ( extension == "VK_EXT_ycbcr_image_arrays" ) ||
|
||||
( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_shader_atomic_float" ) || ( extension == "VK_EXT_index_type_uint8" ) ||
|
||||
( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
|
||||
( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_EXT_robustness2" ) || ( extension == "VK_EXT_custom_border_color" ) ||
|
||||
( extension == "VK_KHR_object_refresh" ) || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) ||
|
||||
( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) ||
|
||||
( extension == "VK_EXT_vertex_input_dynamic_state" )
|
||||
( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" )
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
|| ( extension == "VK_NV_acquire_winrt_display" )
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|| ( extension == "VK_EXT_vertex_input_dynamic_state" )
|
||||
#if defined( VK_USE_PLATFORM_SCI )
|
||||
|| ( extension == "VK_NV_external_sci_sync" ) || ( extension == "VK_NV_external_memory_sci_buf" )
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
@ -681,10 +698,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#if defined( VK_USE_PLATFORM_SCI )
|
||||
|| ( extension == "VK_NV_external_sci_sync2" )
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|| ( extension == "VK_KHR_vertex_attribute_divisor" )
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
|| ( extension == "VK_QNX_external_memory_screen_buffer" )
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
;
|
||||
|| ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_calibrated_timestamps" );
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
|
||||
@ -703,13 +721,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension )
|
||||
{
|
||||
return ( extension == "VK_EXT_texture_compression_astc_hdr" ) || ( extension == "VK_EXT_global_priority" ) ||
|
||||
( extension == "VK_EXT_calibrated_timestamps" ) || ( extension == "VK_EXT_vertex_attribute_divisor" ) ||
|
||||
( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_subgroup_size_control" ) ||
|
||||
( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) ||
|
||||
( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) ||
|
||||
( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_image_robustness" ) ||
|
||||
( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_extended_dynamic_state2" );
|
||||
return ( extension == "VK_EXT_texture_compression_astc_hdr" ) || ( extension == "VK_KHR_shader_terminate_invocation" ) ||
|
||||
( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_index_type_uint8" ) ||
|
||||
( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
|
||||
( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_KHR_synchronization2" ) ||
|
||||
( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) ||
|
||||
( extension == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_extended_dynamic_state2" );
|
||||
}
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
|
@ -10403,167 +10403,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount,
|
||||
VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
return static_cast<Result>(
|
||||
d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( pTimeDomains ) ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename TimeDomainKHRAllocator, typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
||||
PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
|
||||
"Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains;
|
||||
uint32_t timeDomainCount;
|
||||
VULKAN_HPP_NAMESPACE::Result result;
|
||||
do
|
||||
{
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
|
||||
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
|
||||
}
|
||||
} while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
|
||||
VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
|
||||
if ( timeDomainCount < timeDomains.size() )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
}
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) );
|
||||
}
|
||||
|
||||
template <typename TimeDomainKHRAllocator,
|
||||
typename Dispatch,
|
||||
typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
||||
PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
|
||||
"Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator );
|
||||
uint32_t timeDomainCount;
|
||||
VULKAN_HPP_NAMESPACE::Result result;
|
||||
do
|
||||
{
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
|
||||
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
|
||||
}
|
||||
} while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
|
||||
VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
|
||||
if ( timeDomainCount < timeDomains.size() )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
}
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) );
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount,
|
||||
const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
|
||||
uint64_t * pTimestamps,
|
||||
uint64_t * pMaxDeviation,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
return static_cast<Result>( d.vkGetCalibratedTimestampsEXT(
|
||||
m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Uint64_tAllocator, typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
||||
Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
|
||||
Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
|
||||
"Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
|
||||
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
|
||||
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCalibratedTimestampsEXT(
|
||||
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) );
|
||||
}
|
||||
|
||||
template <typename Uint64_tAllocator,
|
||||
typename Dispatch,
|
||||
typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
||||
Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
|
||||
Uint64_tAllocator & uint64_tAllocator,
|
||||
Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
|
||||
"Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
|
||||
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
|
||||
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCalibratedTimestampsEXT(
|
||||
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) );
|
||||
}
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
|
||||
Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
|
||||
"Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::pair<uint64_t, uint64_t> data_;
|
||||
uint64_t & timestamp = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( ×tampInfo ), ×tamp, &maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) );
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
|
||||
template <typename Dispatch>
|
||||
@ -11381,6 +11220,84 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
|
||||
# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
return static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
|
||||
}
|
||||
# else
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
|
||||
PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkAcquireWinrtDisplayNV && "Function <vkAcquireWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
|
||||
# endif
|
||||
|
||||
VULKAN_HPP_NAMESPACE::Result result =
|
||||
static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result );
|
||||
}
|
||||
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId,
|
||||
VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
return static_cast<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
|
||||
}
|
||||
|
||||
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
|
||||
PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function <vkGetWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
|
||||
# endif
|
||||
|
||||
VULKAN_HPP_NAMESPACE::DisplayKHR display;
|
||||
VULKAN_HPP_NAMESPACE::Result result =
|
||||
static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( display ) );
|
||||
}
|
||||
|
||||
# ifndef VULKAN_HPP_NO_SMART_HANDLE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
|
||||
PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function <vkGetWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
|
||||
# endif
|
||||
|
||||
VULKAN_HPP_NAMESPACE::DisplayKHR display;
|
||||
VULKAN_HPP_NAMESPACE::Result result =
|
||||
static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
|
||||
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
|
||||
}
|
||||
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
||||
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
//=== VK_EXT_vertex_input_dynamic_state ===
|
||||
|
||||
template <typename Dispatch>
|
||||
@ -11892,5 +11809,176 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE void
|
||||
CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
d.vkCmdSetLineStippleKHR( m_commandBuffer, lineStippleFactor, lineStipplePattern );
|
||||
}
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount,
|
||||
VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
return static_cast<Result>(
|
||||
d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( pTimeDomains ) ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename TimeDomainKHRAllocator, typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
||||
PhysicalDevice::getCalibrateableTimeDomainsKHR( Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR &&
|
||||
"Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains;
|
||||
uint32_t timeDomainCount;
|
||||
VULKAN_HPP_NAMESPACE::Result result;
|
||||
do
|
||||
{
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) );
|
||||
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
|
||||
}
|
||||
} while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" );
|
||||
VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
|
||||
if ( timeDomainCount < timeDomains.size() )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
}
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) );
|
||||
}
|
||||
|
||||
template <typename TimeDomainKHRAllocator,
|
||||
typename Dispatch,
|
||||
typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
||||
PhysicalDevice::getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR &&
|
||||
"Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator );
|
||||
uint32_t timeDomainCount;
|
||||
VULKAN_HPP_NAMESPACE::Result result;
|
||||
do
|
||||
{
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) );
|
||||
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
|
||||
}
|
||||
} while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" );
|
||||
VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
|
||||
if ( timeDomainCount < timeDomains.size() )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
}
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) );
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsKHR( uint32_t timestampCount,
|
||||
const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
|
||||
uint64_t * pTimestamps,
|
||||
uint64_t * pMaxDeviation,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
return static_cast<Result>( d.vkGetCalibratedTimestampsKHR(
|
||||
m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Uint64_tAllocator, typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
||||
Device::getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
|
||||
Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
|
||||
"Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
|
||||
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
|
||||
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCalibratedTimestampsKHR(
|
||||
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) );
|
||||
}
|
||||
|
||||
template <typename Uint64_tAllocator,
|
||||
typename Dispatch,
|
||||
typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
||||
Device::getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
|
||||
Uint64_tAllocator & uint64_tAllocator,
|
||||
Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
|
||||
"Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
|
||||
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
|
||||
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCalibratedTimestampsKHR(
|
||||
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) );
|
||||
}
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
|
||||
Device::getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
|
||||
VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
|
||||
"Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
# endif
|
||||
|
||||
std::pair<uint64_t, uint64_t> data_;
|
||||
uint64_t & timestamp = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
d.vkGetCalibratedTimestampsKHR( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( ×tampInfo ), ×tamp, &maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" );
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) );
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
#endif
|
||||
|
@ -605,8 +605,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_KHR_shader_clock ===
|
||||
struct PhysicalDeviceShaderClockFeaturesKHR;
|
||||
|
||||
//=== VK_EXT_vertex_attribute_divisor ===
|
||||
struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
|
||||
//=== VK_KHR_global_priority ===
|
||||
struct DeviceQueueGlobalPriorityCreateInfoKHR;
|
||||
using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR;
|
||||
struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
|
||||
using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
|
||||
struct QueueFamilyGlobalPriorityPropertiesKHR;
|
||||
using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR;
|
||||
|
||||
//=== VK_EXT_pci_bus_info ===
|
||||
struct PhysicalDevicePCIBusInfoPropertiesEXT;
|
||||
@ -713,6 +718,15 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
struct DeviceSemaphoreSciSyncPoolReservationCreateInfoNV;
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_vertex_attribute_divisor ===
|
||||
struct PhysicalDeviceVertexAttributeDivisorPropertiesKHR;
|
||||
struct VertexInputBindingDivisorDescriptionKHR;
|
||||
using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescriptionKHR;
|
||||
struct PipelineVertexInputDivisorStateCreateInfoKHR;
|
||||
using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfoKHR;
|
||||
struct PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
|
||||
using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
struct ScreenBufferPropertiesQNX;
|
||||
@ -722,6 +736,22 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
struct PhysicalDeviceIndexTypeUint8FeaturesKHR;
|
||||
using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8FeaturesKHR;
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
struct PhysicalDeviceLineRasterizationFeaturesKHR;
|
||||
using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeaturesKHR;
|
||||
struct PhysicalDeviceLineRasterizationPropertiesKHR;
|
||||
using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationPropertiesKHR;
|
||||
struct PipelineRasterizationLineStateCreateInfoKHR;
|
||||
using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfoKHR;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
struct CalibratedTimestampInfoKHR;
|
||||
using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;
|
||||
|
||||
//===================================
|
||||
//=== HANDLE forward declarations ===
|
||||
//===================================
|
||||
@ -1203,6 +1233,105 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
||||
};
|
||||
|
||||
class DisplayKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkDisplayKHR;
|
||||
using NativeType = VkDisplayKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
|
||||
|
||||
public:
|
||||
DisplayKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
|
||||
DisplayKHR( DisplayKHR const & rhs ) = default;
|
||||
DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
|
||||
DisplayKHR( DisplayKHR && rhs ) = default;
|
||||
DisplayKHR & operator=( DisplayKHR && rhs ) = default;
|
||||
|
||||
VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
||||
|
||||
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
|
||||
|
||||
#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
||||
DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
m_displayKHR = displayKHR;
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
m_displayKHR = {};
|
||||
return *this;
|
||||
}
|
||||
|
||||
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
|
||||
auto operator<=>( DisplayKHR const & ) const = default;
|
||||
#else
|
||||
bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR == rhs.m_displayKHR;
|
||||
}
|
||||
|
||||
bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR != rhs.m_displayKHR;
|
||||
}
|
||||
|
||||
bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR < rhs.m_displayKHR;
|
||||
}
|
||||
#endif
|
||||
|
||||
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR;
|
||||
}
|
||||
|
||||
explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR != VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
bool operator!() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR == VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
private:
|
||||
VkDisplayKHR m_displayKHR = {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
|
||||
{
|
||||
using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
|
||||
{
|
||||
using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
|
||||
};
|
||||
|
||||
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
||||
template <>
|
||||
struct CppType<VkDisplayKHR, VK_NULL_HANDLE>
|
||||
{
|
||||
using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
|
||||
};
|
||||
#endif
|
||||
|
||||
template <>
|
||||
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
||||
};
|
||||
|
||||
class SwapchainKHR
|
||||
{
|
||||
public:
|
||||
@ -3298,6 +3427,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
void setLineStippleKHR( uint32_t lineStippleFactor,
|
||||
uint16_t lineStipplePattern,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_commandBuffer;
|
||||
@ -4633,105 +4769,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
};
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
class DisplayKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkDisplayKHR;
|
||||
using NativeType = VkDisplayKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
|
||||
|
||||
public:
|
||||
DisplayKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
|
||||
DisplayKHR( DisplayKHR const & rhs ) = default;
|
||||
DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
|
||||
DisplayKHR( DisplayKHR && rhs ) = default;
|
||||
DisplayKHR & operator=( DisplayKHR && rhs ) = default;
|
||||
|
||||
VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
||||
|
||||
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
|
||||
|
||||
#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
||||
DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
m_displayKHR = displayKHR;
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
m_displayKHR = {};
|
||||
return *this;
|
||||
}
|
||||
|
||||
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
|
||||
auto operator<=>( DisplayKHR const & ) const = default;
|
||||
#else
|
||||
bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR == rhs.m_displayKHR;
|
||||
}
|
||||
|
||||
bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR != rhs.m_displayKHR;
|
||||
}
|
||||
|
||||
bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR < rhs.m_displayKHR;
|
||||
}
|
||||
#endif
|
||||
|
||||
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR;
|
||||
}
|
||||
|
||||
explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR != VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
bool operator!() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_displayKHR == VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
private:
|
||||
VkDisplayKHR m_displayKHR = {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
|
||||
{
|
||||
using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
|
||||
{
|
||||
using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
|
||||
};
|
||||
|
||||
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
||||
template <>
|
||||
struct CppType<VkDisplayKHR, VK_NULL_HANDLE>
|
||||
{
|
||||
using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
|
||||
};
|
||||
#endif
|
||||
|
||||
template <>
|
||||
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
||||
};
|
||||
|
||||
class Queue
|
||||
{
|
||||
public:
|
||||
@ -6894,32 +6931,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount,
|
||||
const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
|
||||
uint64_t * pTimestamps,
|
||||
uint64_t * pMaxDeviation,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
||||
getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
template <typename Uint64_tAllocator = std::allocator<uint64_t>,
|
||||
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
||||
typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
||||
getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
|
||||
Uint64_tAllocator & uint64_tAllocator,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
|
||||
getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCI )
|
||||
//=== VK_NV_external_sci_sync ===
|
||||
|
||||
@ -7042,6 +7053,32 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t timestampCount,
|
||||
const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
|
||||
uint64_t * pTimestamps,
|
||||
uint64_t * pMaxDeviation,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
||||
getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
template <typename Uint64_tAllocator = std::allocator<uint64_t>,
|
||||
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
||||
typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
||||
getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
|
||||
Uint64_tAllocator & uint64_tAllocator,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
|
||||
getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
operator VkDevice() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_device;
|
||||
@ -7912,23 +7949,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount,
|
||||
VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
||||
getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
|
||||
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
||||
typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
||||
getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
@ -7969,6 +7989,35 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
getRefreshableObjectTypesKHR( ObjectTypeAllocator & objectTypeAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
|
||||
# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
# else
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
||||
acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId,
|
||||
VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
|
||||
getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
# ifndef VULKAN_HPP_NO_SMART_HANDLE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
|
||||
getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
||||
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCI )
|
||||
//=== VK_NV_external_sci_sync ===
|
||||
|
||||
@ -8011,6 +8060,23 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount,
|
||||
VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
||||
getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
|
||||
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
||||
typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
|
||||
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
||||
getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_physicalDevice;
|
||||
|
@ -978,6 +978,19 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
|
||||
{
|
||||
@ -2071,6 +2084,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR const & deviceQueueGlobalPriorityCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.globalPriority );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2>
|
||||
{
|
||||
@ -4545,6 +4572,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const & physicalDeviceGlobalPriorityQueryFeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
|
||||
{
|
||||
@ -4678,6 +4719,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR const & physicalDeviceIndexTypeUint8FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.indexTypeUint8 );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures>
|
||||
{
|
||||
@ -4845,6 +4900,39 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR const & physicalDeviceLineRasterizationFeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.rectangularLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.bresenhamLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.smoothLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledRectangularLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledBresenhamLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledSmoothLines );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR const & physicalDeviceLineRasterizationPropertiesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.lineSubPixelPrecisionBits );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
|
||||
{
|
||||
@ -5650,15 +5738,31 @@ namespace std
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT )
|
||||
std::size_t operator()(
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR const & physicalDeviceVertexAttributeDivisorFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateDivisor );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateZeroDivisor );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR const & physicalDeviceVertexAttributeDivisorPropertiesKHR )
|
||||
const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.maxVertexAttribDivisor );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.supportsNonZeroFirstInstance );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
@ -6293,6 +6397,23 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR const & pipelineRasterizationLineStateCreateInfoKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineRasterizationMode );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.stippledLineEnable );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineStippleFactor );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineStipplePattern );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo>
|
||||
{
|
||||
@ -6353,6 +6474,34 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR const & vertexInputBindingDivisorDescriptionKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.binding );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.divisor );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR const & pipelineVertexInputDivisorStateCreateInfoKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.vertexBindingDivisorCount );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pVertexBindingDivisors );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR>
|
||||
{
|
||||
@ -6480,6 +6629,24 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR const & queueFamilyGlobalPriorityPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorityCount );
|
||||
for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i )
|
||||
{
|
||||
VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorities[i] );
|
||||
}
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
|
||||
{
|
||||
|
@ -174,12 +174,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
vkGetPhysicalDeviceMultisamplePropertiesEXT =
|
||||
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
vkGetPhysicalDeviceCalibrateableTimeDomainsEXT =
|
||||
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
|
||||
if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR )
|
||||
vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
vkGetPhysicalDeviceFragmentShadingRatesKHR =
|
||||
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
|
||||
@ -191,6 +185,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
vkGetPhysicalDeviceRefreshableObjectTypesKHR =
|
||||
PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceRefreshableObjectTypesKHR" ) );
|
||||
|
||||
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
|
||||
vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
# if defined( VK_USE_PLATFORM_SCI )
|
||||
//=== VK_NV_external_sci_sync ===
|
||||
vkGetPhysicalDeviceSciSyncAttributesNV =
|
||||
@ -205,6 +205,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
PFN_vkGetPhysicalDeviceSciBufAttributesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSciBufAttributesNV" ) );
|
||||
# endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
vkGetPhysicalDeviceCalibrateableTimeDomainsKHR =
|
||||
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) );
|
||||
|
||||
vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
|
||||
}
|
||||
|
||||
@ -285,9 +289,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_sample_locations ===
|
||||
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
|
||||
|
||||
@ -297,6 +298,15 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_KHR_object_refresh ===
|
||||
PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR vkGetPhysicalDeviceRefreshableObjectTypesKHR = 0;
|
||||
|
||||
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
|
||||
PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
|
||||
# else
|
||||
PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0;
|
||||
PFN_dummy vkGetWinrtDisplayNV_placeholder = 0;
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
# if defined( VK_USE_PLATFORM_SCI )
|
||||
//=== VK_NV_external_sci_sync ===
|
||||
PFN_vkGetPhysicalDeviceSciSyncAttributesNV vkGetPhysicalDeviceSciSyncAttributesNV = 0;
|
||||
@ -313,6 +323,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
PFN_dummy vkGetPhysicalDeviceSciBufAttributesNV_placeholder = 0;
|
||||
# endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0;
|
||||
|
||||
PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
|
||||
};
|
||||
|
||||
@ -573,11 +586,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_external_memory_host ===
|
||||
vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
|
||||
if ( !vkGetCalibratedTimestampsKHR )
|
||||
vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
|
||||
|
||||
@ -712,6 +720,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) );
|
||||
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) );
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) );
|
||||
}
|
||||
|
||||
public:
|
||||
@ -962,9 +976,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_external_memory_host ===
|
||||
PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0;
|
||||
|
||||
@ -1056,6 +1067,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
# else
|
||||
PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0;
|
||||
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0;
|
||||
};
|
||||
|
||||
//========================================
|
||||
@ -1567,10 +1584,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
|
||||
getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> getCalibrateableTimeDomainsEXT() const;
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
|
||||
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> getFragmentShadingRatesKHR() const;
|
||||
@ -1579,6 +1592,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ObjectType> getRefreshableObjectTypesKHR() const;
|
||||
|
||||
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type
|
||||
getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
# if defined( VK_USE_PLATFORM_SCI )
|
||||
//=== VK_NV_external_sci_sync ===
|
||||
|
||||
@ -1594,6 +1614,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
void getSciBufAttributesNV( NvSciBufAttrList pAttributes ) const;
|
||||
# endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> getCalibrateableTimeDomainsKHR() const;
|
||||
|
||||
private:
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {};
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
|
||||
@ -2027,14 +2051,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT
|
||||
getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const;
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t>
|
||||
getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const;
|
||||
|
||||
VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t>
|
||||
getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const;
|
||||
|
||||
# if defined( VK_USE_PLATFORM_SCI )
|
||||
//=== VK_NV_external_sci_sync ===
|
||||
|
||||
@ -2079,6 +2095,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const;
|
||||
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t>
|
||||
getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const;
|
||||
|
||||
VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t>
|
||||
getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const;
|
||||
|
||||
private:
|
||||
VULKAN_HPP_NAMESPACE::Device m_device = {};
|
||||
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
|
||||
@ -2957,6 +2981,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
void setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
private:
|
||||
VULKAN_HPP_NAMESPACE::Device m_device = {};
|
||||
VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {};
|
||||
@ -3627,6 +3655,15 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
|
||||
|
||||
public:
|
||||
# if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
|
||||
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, uint32_t deviceRelativeId )
|
||||
{
|
||||
*this = physicalDevice.getWinrtDisplayNV( deviceRelativeId );
|
||||
}
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
# endif
|
||||
|
||||
DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VkDisplayKHR display )
|
||||
: m_physicalDevice( physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() )
|
||||
{
|
||||
@ -3721,6 +3758,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const;
|
||||
|
||||
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
|
||||
void acquireWinrtNV() const;
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
private:
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {};
|
||||
VULKAN_HPP_NAMESPACE::DisplayKHR m_display = {};
|
||||
@ -10418,73 +10461,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
return memoryHostPointerProperties;
|
||||
}
|
||||
|
||||
//=== VK_EXT_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> PhysicalDevice::getCalibrateableTimeDomainsEXT() const
|
||||
{
|
||||
VULKAN_HPP_ASSERT(
|
||||
getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
|
||||
"Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
|
||||
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> timeDomains;
|
||||
uint32_t timeDomainCount;
|
||||
VULKAN_HPP_NAMESPACE::Result result;
|
||||
do
|
||||
{
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) );
|
||||
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
|
||||
static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
|
||||
}
|
||||
} while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
|
||||
VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
|
||||
if ( timeDomainCount < timeDomains.size() )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
}
|
||||
return timeDomains;
|
||||
}
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> Device::getCalibratedTimestampsEXT(
|
||||
VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT &&
|
||||
"Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
|
||||
std::pair<std::vector<uint64_t>, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
|
||||
std::vector<uint64_t> & timestamps = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ),
|
||||
timestampInfos.size(),
|
||||
reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ),
|
||||
timestamps.data(),
|
||||
&maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
|
||||
|
||||
return data_;
|
||||
}
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t>
|
||||
Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT &&
|
||||
"Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
|
||||
std::pair<uint64_t, uint64_t> data_;
|
||||
uint64_t & timestamp = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsEXT(
|
||||
static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( ×tampInfo ), ×tamp, &maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
|
||||
|
||||
return data_;
|
||||
}
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
|
||||
@ -10900,6 +10876,38 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
|
||||
}
|
||||
|
||||
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
|
||||
VULKAN_HPP_INLINE void DisplayKHR::acquireWinrtNV() const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV && "Function <vkAcquireWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
|
||||
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
getDispatcher()->vkAcquireWinrtDisplayNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" );
|
||||
}
|
||||
|
||||
VULKAN_HPP_NODISCARD
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type
|
||||
PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::DisplayKHR display;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetWinrtDisplayNV(
|
||||
static_cast<VkPhysicalDevice>( m_physicalDevice ), deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
# if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
|
||||
return VULKAN_HPP_UNEXPECTED( result );
|
||||
# else
|
||||
VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getWinrtDisplayNV" );
|
||||
# endif
|
||||
}
|
||||
|
||||
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) );
|
||||
}
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
//=== VK_EXT_vertex_input_dynamic_state ===
|
||||
|
||||
VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
|
||||
@ -11166,6 +11174,83 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
VULKAN_HPP_INLINE void CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleKHR &&
|
||||
"Function <vkCmdSetLineStippleKHR> requires <VK_EXT_line_rasterization> or <VK_KHR_line_rasterization>" );
|
||||
|
||||
getDispatcher()->vkCmdSetLineStippleKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
|
||||
}
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> PhysicalDevice::getCalibrateableTimeDomainsKHR() const
|
||||
{
|
||||
VULKAN_HPP_ASSERT(
|
||||
getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR &&
|
||||
"Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
|
||||
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> timeDomains;
|
||||
uint32_t timeDomainCount;
|
||||
VULKAN_HPP_NAMESPACE::Result result;
|
||||
do
|
||||
{
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) );
|
||||
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(
|
||||
static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
|
||||
}
|
||||
} while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" );
|
||||
VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
|
||||
if ( timeDomainCount < timeDomains.size() )
|
||||
{
|
||||
timeDomains.resize( timeDomainCount );
|
||||
}
|
||||
return timeDomains;
|
||||
}
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> Device::getCalibratedTimestampsKHR(
|
||||
VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR &&
|
||||
"Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
|
||||
std::pair<std::vector<uint64_t>, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
|
||||
std::vector<uint64_t> & timestamps = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
|
||||
getDispatcher()->vkGetCalibratedTimestampsKHR( static_cast<VkDevice>( m_device ),
|
||||
timestampInfos.size(),
|
||||
reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ),
|
||||
timestamps.data(),
|
||||
&maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" );
|
||||
|
||||
return data_;
|
||||
}
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t>
|
||||
Device::getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR &&
|
||||
"Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
|
||||
|
||||
std::pair<uint64_t, uint64_t> data_;
|
||||
uint64_t & timestamp = data_.first;
|
||||
uint64_t & maxDeviation = data_.second;
|
||||
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsKHR(
|
||||
static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( ×tampInfo ), ×tamp, &maxDeviation ) );
|
||||
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" );
|
||||
|
||||
return data_;
|
||||
}
|
||||
|
||||
//====================
|
||||
//=== RAII Helpers ===
|
||||
//====================
|
||||
|
@ -2425,15 +2425,29 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>::value,
|
||||
"PhysicalDeviceShaderClockFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_vertex_attribute_divisor ===
|
||||
//=== VK_KHR_global_priority ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) ==
|
||||
sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ),
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::value,
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::value,
|
||||
"PhysicalDeviceVertexAttributeDivisorPropertiesEXT is not nothrow_move_constructible!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR>::value,
|
||||
"DeviceQueueGlobalPriorityCreateInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>::value,
|
||||
"PhysicalDeviceGlobalPriorityQueryFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR ) == sizeof( VkQueueFamilyGlobalPriorityPropertiesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR>::value,
|
||||
"QueueFamilyGlobalPriorityPropertiesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_pci_bus_info ===
|
||||
|
||||
@ -2835,6 +2849,39 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
|
||||
"DeviceSemaphoreSciSyncPoolReservationCreateInfoNV is not nothrow_move_constructible!" );
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_vertex_attribute_divisor ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR>::value,
|
||||
"PhysicalDeviceVertexAttributeDivisorPropertiesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR ) == sizeof( VkVertexInputBindingDivisorDescriptionKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR>::value,
|
||||
"VertexInputBindingDivisorDescriptionKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR ) ==
|
||||
sizeof( VkPipelineVertexInputDivisorStateCreateInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR>::value,
|
||||
"PipelineVertexInputDivisorStateCreateInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>::value,
|
||||
"PhysicalDeviceVertexAttributeDivisorFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
|
||||
@ -2870,4 +2917,46 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
|
||||
"PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX is not nothrow_move_constructible!" );
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>::value,
|
||||
"PhysicalDeviceIndexTypeUint8FeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>::value,
|
||||
"PhysicalDeviceLineRasterizationFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceLineRasterizationPropertiesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>::value,
|
||||
"PhysicalDeviceLineRasterizationPropertiesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR ) ==
|
||||
sizeof( VkPipelineRasterizationLineStateCreateInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>::value,
|
||||
"PipelineRasterizationLineStateCreateInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR ) == sizeof( VkCalibratedTimestampInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>::value,
|
||||
"CalibratedTimestampInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
#endif
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -1676,6 +1676,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR";
|
||||
case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR";
|
||||
case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
|
||||
case Result::eErrorNotPermittedKHR: return "ErrorNotPermittedKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -1977,7 +1978,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT";
|
||||
case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
|
||||
case StructureType::ePhysicalDeviceShaderClockFeaturesKHR: return "PhysicalDeviceShaderClockFeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
|
||||
case StructureType::eDeviceQueueGlobalPriorityCreateInfoKHR: return "DeviceQueueGlobalPriorityCreateInfoKHR";
|
||||
case StructureType::ePhysicalDeviceGlobalPriorityQueryFeaturesKHR: return "PhysicalDeviceGlobalPriorityQueryFeaturesKHR";
|
||||
case StructureType::eQueueFamilyGlobalPriorityPropertiesKHR: return "QueueFamilyGlobalPriorityPropertiesKHR";
|
||||
case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT: return "PhysicalDevicePciBusInfoPropertiesEXT";
|
||||
case StructureType::eFragmentShadingRateAttachmentInfoKHR: return "FragmentShadingRateAttachmentInfoKHR";
|
||||
case StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR: return "PipelineFragmentShadingRateStateCreateInfoKHR";
|
||||
@ -2031,6 +2034,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::ePhysicalDeviceExternalSciSync2FeaturesNV: return "PhysicalDeviceExternalSciSync2FeaturesNV";
|
||||
case StructureType::eDeviceSemaphoreSciSyncPoolReservationCreateInfoNV: return "DeviceSemaphoreSciSyncPoolReservationCreateInfoNV";
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesKHR: return "PhysicalDeviceVertexAttributeDivisorPropertiesKHR";
|
||||
case StructureType::ePipelineVertexInputDivisorStateCreateInfoKHR: return "PipelineVertexInputDivisorStateCreateInfoKHR";
|
||||
case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesKHR: return "PhysicalDeviceVertexAttributeDivisorFeaturesKHR";
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
case StructureType::eScreenBufferPropertiesQNX: return "ScreenBufferPropertiesQNX";
|
||||
case StructureType::eScreenBufferFormatPropertiesQNX: return "ScreenBufferFormatPropertiesQNX";
|
||||
@ -2038,6 +2044,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eExternalFormatQNX: return "ExternalFormatQNX";
|
||||
case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesKHR: return "PhysicalDeviceIndexTypeUint8FeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceLineRasterizationFeaturesKHR: return "PhysicalDeviceLineRasterizationFeaturesKHR";
|
||||
case StructureType::ePipelineRasterizationLineStateCreateInfoKHR: return "PipelineRasterizationLineStateCreateInfoKHR";
|
||||
case StructureType::ePhysicalDeviceLineRasterizationPropertiesKHR: return "PhysicalDeviceLineRasterizationPropertiesKHR";
|
||||
case StructureType::eCalibratedTimestampInfoKHR: return "CalibratedTimestampInfoKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -2965,6 +2976,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case DynamicState::ePatchControlPointsEXT: return "PatchControlPointsEXT";
|
||||
case DynamicState::eLogicOpEXT: return "LogicOpEXT";
|
||||
case DynamicState::eColorWriteEnableEXT: return "ColorWriteEnableEXT";
|
||||
case DynamicState::eLineStippleKHR: return "LineStippleKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -3407,6 +3419,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
case IndexType::eUint16: return "Uint16";
|
||||
case IndexType::eUint32: return "Uint32";
|
||||
case IndexType::eUint8KHR: return "Uint8KHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -4270,6 +4283,20 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_KHR_global_priority ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( QueueGlobalPriorityKHR value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case QueueGlobalPriorityKHR::eLow: return "Low";
|
||||
case QueueGlobalPriorityKHR::eMedium: return "Medium";
|
||||
case QueueGlobalPriorityKHR::eHigh: return "High";
|
||||
case QueueGlobalPriorityKHR::eRealtime: return "Realtime";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_KHR_fragment_shading_rate ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( FragmentShadingRateCombinerOpKHR value )
|
||||
@ -4355,5 +4382,33 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
#endif /*VK_USE_PLATFORM_SCI*/
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeKHR value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case LineRasterizationModeKHR::eDefault: return "Default";
|
||||
case LineRasterizationModeKHR::eRectangular: return "Rectangular";
|
||||
case LineRasterizationModeKHR::eBresenham: return "Bresenham";
|
||||
case LineRasterizationModeKHR::eRectangularSmooth: return "RectangularSmooth";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( TimeDomainKHR value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case TimeDomainKHR::eDevice: return "Device";
|
||||
case TimeDomainKHR::eClockMonotonic: return "ClockMonotonic";
|
||||
case TimeDomainKHR::eClockMonotonicRaw: return "ClockMonotonicRaw";
|
||||
case TimeDomainKHR::eQueryPerformanceCounter: return "QueryPerformanceCounter";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
#endif
|
||||
|
Loading…
Reference in New Issue
Block a user