From d2a1056a56abcb2cf83c642b6298700a6768b674 Mon Sep 17 00:00:00 2001 From: Markus Tavenrath Date: Thu, 30 May 2019 09:18:32 +0200 Subject: [PATCH] Add support for Vulkan header version 109 (#333) --- Vulkan-Docs | 2 +- VulkanHppGenerator.cpp | 9 + vulkan/vulkan.hpp | 2740 ++++++++++++++++++++++++++++++++++++++-- 3 files changed, 2668 insertions(+), 83 deletions(-) diff --git a/Vulkan-Docs b/Vulkan-Docs index 8cc971f..6635a81 160000 --- a/Vulkan-Docs +++ b/Vulkan-Docs @@ -1 +1 @@ -Subproject commit 8cc971fb3e1c25afb949cdc49d6a6de63f19c5c6 +Subproject commit 6635a81b5b9dea234faf967d54abf7241db371c9 diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 3ba2e3c..519652f 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -4016,6 +4016,15 @@ void VulkanHppGenerator::writeUnion(std::ostream & os, std::pair& ")) << member.name << "_"; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index da72453..bb4c136 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -56,7 +56,7 @@ # define VULKAN_HPP_ASSERT assert #endif -static_assert( VK_HEADER_VERSION == 103 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 109 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -1018,6 +1018,21 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCmdSetLineWidth( commandBuffer, lineWidth ); } + VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo ) const + { + return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo ); + } + + VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo ) const + { + return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo ); + } + + VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo ) const + { + return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo ); + } + void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo ) const { return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo ); @@ -1098,6 +1113,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkResetCommandBuffer( commandBuffer, flags ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const + { + return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex ) const { return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex ); @@ -1108,6 +1130,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex ); } + VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration ) const + { + return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration ); + } + VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers ) const { return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers ); @@ -1565,6 +1592,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes ) const + { + return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes ) const { return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes ); @@ -1705,6 +1739,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings ); } + VkResult vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue ) const + { + return ::vkGetPerformanceParameterINTEL( device, parameter, pValue ); + } + VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData ) const { return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData ); @@ -1791,6 +1830,11 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo ) const + { + return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo ); + } + VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const { return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); @@ -1826,6 +1870,18 @@ namespace VULKAN_HPP_NAMESPACE return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const + { + return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const + { + return ::vkReleasePerformanceConfigurationINTEL( device, configuration ); + } + VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const { return ::vkResetCommandPool( device, commandPool, flags ); @@ -1846,6 +1902,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkResetFences( device, fenceCount, pFences ); } + void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const + { + return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount ); + } + VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo ) const { return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo ); @@ -1866,6 +1927,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata ); } + void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const + { + return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable ); + } + void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const { return ::vkTrimCommandPool( device, commandPool, flags ); @@ -1876,6 +1942,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkTrimCommandPoolKHR( device, commandPool, flags ); } + void vkUninitializePerformanceApiINTEL( VkDevice device ) const + { + return ::vkUninitializePerformanceApiINTEL( device ); + } + void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const { return ::vkUnmapMemory( device, memory ); @@ -1928,6 +1999,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); } + VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); + } + #ifdef VK_USE_PLATFORM_IOS_MVK VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const { @@ -1956,6 +2032,13 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface ); + } +#endif /*VK_USE_PLATFORM_GGP*/ + #ifdef VK_USE_PLATFORM_VI_NN VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const { @@ -2278,6 +2361,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties ); } + VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations ) const + { + return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations ); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities ) const { return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities ); @@ -2303,6 +2391,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const + { + return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const { return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes ); @@ -2383,6 +2478,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkQueuePresentKHR( queue, pPresentInfo ); } + VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const + { + return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration ); + } + VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence ) const { return ::vkQueueSubmit( queue, submitCount, pSubmits, fence ); @@ -2827,7 +2927,7 @@ namespace VULKAN_HPP_NAMESPACE eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, - eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, + eDisplayP3LinearEXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, @@ -2839,7 +2939,9 @@ namespace VULKAN_HPP_NAMESPACE eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT, eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT, - eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR + eDisplayNativeAMD = VK_COLOR_SPACE_DISPLAY_NATIVE_AMD, + eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR, + eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT }; VULKAN_HPP_INLINE std::string to_string( ColorSpaceKHR value ) @@ -2849,7 +2951,7 @@ namespace VULKAN_HPP_NAMESPACE case ColorSpaceKHR::eSrgbNonlinear : return "SrgbNonlinear"; case ColorSpaceKHR::eDisplayP3NonlinearEXT : return "DisplayP3NonlinearEXT"; case ColorSpaceKHR::eExtendedSrgbLinearEXT : return "ExtendedSrgbLinearEXT"; - case ColorSpaceKHR::eDciP3LinearEXT : return "DciP3LinearEXT"; + case ColorSpaceKHR::eDisplayP3LinearEXT : return "DisplayP3LinearEXT"; case ColorSpaceKHR::eDciP3NonlinearEXT : return "DciP3NonlinearEXT"; case ColorSpaceKHR::eBt709LinearEXT : return "Bt709LinearEXT"; case ColorSpaceKHR::eBt709NonlinearEXT : return "Bt709NonlinearEXT"; @@ -2861,6 +2963,7 @@ namespace VULKAN_HPP_NAMESPACE case ColorSpaceKHR::eAdobergbNonlinearEXT : return "AdobergbNonlinearEXT"; case ColorSpaceKHR::ePassThroughEXT : return "PassThroughEXT"; case ColorSpaceKHR::eExtendedSrgbNonlinearEXT : return "ExtendedSrgbNonlinearEXT"; + case ColorSpaceKHR::eDisplayNativeAMD : return "DisplayNativeAMD"; default: return "invalid"; } } @@ -3023,6 +3126,22 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class CoverageReductionModeNV + { + eMerge = VK_COVERAGE_REDUCTION_MODE_MERGE_NV, + eTruncate = VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV + }; + + VULKAN_HPP_INLINE std::string to_string( CoverageReductionModeNV value ) + { + switch ( value ) + { + case CoverageReductionModeNV::eMerge : return "Merge"; + case CoverageReductionModeNV::eTruncate : return "Truncate"; + default: return "invalid"; + } + } + enum class DebugReportObjectTypeEXT { eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, @@ -3241,7 +3360,8 @@ namespace VULKAN_HPP_NAMESPACE eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR, eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR, eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR, - eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR + eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR, + eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY_KHR }; VULKAN_HPP_INLINE std::string to_string( DriverIdKHR value ) @@ -3258,6 +3378,7 @@ namespace VULKAN_HPP_NAMESPACE case DriverIdKHR::eQualcommProprietary : return "QualcommProprietary"; case DriverIdKHR::eArmProprietary : return "ArmProprietary"; case DriverIdKHR::eGooglePastel : return "GooglePastel"; + case DriverIdKHR::eGgpProprietary : return "GgpProprietary"; default: return "invalid"; } } @@ -3839,6 +3960,28 @@ namespace VULKAN_HPP_NAMESPACE } } +#ifdef VK_USE_PLATFORM_WIN32_KHR + enum class FullScreenExclusiveEXT + { + eDefault = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, + eAllowed = VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT, + eDisallowed = VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT, + eApplicationControlled = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( FullScreenExclusiveEXT value ) + { + switch ( value ) + { + case FullScreenExclusiveEXT::eDefault : return "Default"; + case FullScreenExclusiveEXT::eAllowed : return "Allowed"; + case FullScreenExclusiveEXT::eDisallowed : return "Disallowed"; + case FullScreenExclusiveEXT::eApplicationControlled : return "ApplicationControlled"; + default: return "invalid"; + } + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + enum class GeometryTypeNV { eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NV, @@ -4145,6 +4288,7 @@ namespace VULKAN_HPP_NAMESPACE eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, + ePerformanceConfigurationINTEL = VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR }; @@ -4191,6 +4335,75 @@ namespace VULKAN_HPP_NAMESPACE case ObjectType::eDebugUtilsMessengerEXT : return "DebugUtilsMessengerEXT"; case ObjectType::eValidationCacheEXT : return "ValidationCacheEXT"; case ObjectType::eAccelerationStructureNV : return "AccelerationStructureNV"; + case ObjectType::ePerformanceConfigurationINTEL : return "PerformanceConfigurationINTEL"; + default: return "invalid"; + } + } + + enum class PerformanceConfigurationTypeINTEL + { + eCommandQueueMetricsDiscoveryActivated = VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL + }; + + VULKAN_HPP_INLINE std::string to_string( PerformanceConfigurationTypeINTEL value ) + { + switch ( value ) + { + case PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated : return "CommandQueueMetricsDiscoveryActivated"; + default: return "invalid"; + } + } + + enum class PerformanceOverrideTypeINTEL + { + eNullHardware = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL, + eFlushGpuCaches = VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL + }; + + VULKAN_HPP_INLINE std::string to_string( PerformanceOverrideTypeINTEL value ) + { + switch ( value ) + { + case PerformanceOverrideTypeINTEL::eNullHardware : return "NullHardware"; + case PerformanceOverrideTypeINTEL::eFlushGpuCaches : return "FlushGpuCaches"; + default: return "invalid"; + } + } + + enum class PerformanceParameterTypeINTEL + { + eHwCountersSupported = VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL, + eStreamMarkerValidBits = VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL + }; + + VULKAN_HPP_INLINE std::string to_string( PerformanceParameterTypeINTEL value ) + { + switch ( value ) + { + case PerformanceParameterTypeINTEL::eHwCountersSupported : return "HwCountersSupported"; + case PerformanceParameterTypeINTEL::eStreamMarkerValidBits : return "StreamMarkerValidBits"; + default: return "invalid"; + } + } + + enum class PerformanceValueTypeINTEL + { + eUint32 = VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL, + eUint64 = VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL, + eFloat = VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL, + eBool = VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL, + eString = VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL + }; + + VULKAN_HPP_INLINE std::string to_string( PerformanceValueTypeINTEL value ) + { + switch ( value ) + { + case PerformanceValueTypeINTEL::eUint32 : return "Uint32"; + case PerformanceValueTypeINTEL::eUint64 : return "Uint64"; + case PerformanceValueTypeINTEL::eFloat : return "Float"; + case PerformanceValueTypeINTEL::eBool : return "Bool"; + case PerformanceValueTypeINTEL::eString : return "String"; default: return "invalid"; } } @@ -4345,13 +4558,28 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class QueryPoolSamplingModeINTEL + { + eManual = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL + }; + + VULKAN_HPP_INLINE std::string to_string( QueryPoolSamplingModeINTEL value ) + { + switch ( value ) + { + case QueryPoolSamplingModeINTEL::eManual : return "Manual"; + default: return "invalid"; + } + } + enum class QueryType { eOcclusion = VK_QUERY_TYPE_OCCLUSION, ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, eTimestamp = VK_QUERY_TYPE_TIMESTAMP, eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT, - eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV + eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV, + ePerformanceQueryINTEL = VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL }; VULKAN_HPP_INLINE std::string to_string( QueryType value ) @@ -4363,6 +4591,7 @@ namespace VULKAN_HPP_NAMESPACE case QueryType::eTimestamp : return "Timestamp"; case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT"; case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV"; + case QueryType::ePerformanceQueryINTEL : return "PerformanceQueryINTEL"; default: return "invalid"; } } @@ -4454,6 +4683,7 @@ namespace VULKAN_HPP_NAMESPACE eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT, eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT, eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT, + eErrorFullScreenExclusiveModeLostEXT = VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR }; @@ -4493,6 +4723,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorFragmentationEXT : return "ErrorFragmentationEXT"; case Result::eErrorNotPermittedEXT : return "ErrorNotPermittedEXT"; case Result::eErrorInvalidDeviceAddressEXT : return "ErrorInvalidDeviceAddressEXT"; + case Result::eErrorFullScreenExclusiveModeLostEXT : return "ErrorFullScreenExclusiveModeLostEXT"; default: return "invalid"; } } @@ -4803,7 +5034,7 @@ namespace VULKAN_HPP_NAMESPACE eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, + ePhysicalDeviceVariablePointersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, @@ -4831,7 +5062,7 @@ namespace VULKAN_HPP_NAMESPACE eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, - ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, + ePhysicalDeviceShaderDrawParametersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, eDeviceGroupPresentCapabilitiesKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, @@ -4861,6 +5092,7 @@ namespace VULKAN_HPP_NAMESPACE ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX, eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, + eStreamDescriptorSurfaceCreateInfoGGP = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP, ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, @@ -5008,6 +5240,8 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, + ePresentFrameTokenGGP = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP, + ePipelineCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT, ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR, ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, ePhysicalDeviceDepthStencilResolvePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, @@ -5021,8 +5255,17 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV, eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, + ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL, + eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL, + eInitializePerformanceApiInfoINTEL = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL, + ePerformanceMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL, + ePerformanceStreamMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL, + ePerformanceOverrideInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL, + ePerformanceConfigurationAcquireInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL, ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, + eDisplayNativeHdrSurfaceCapabilitiesAMD = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, + eSwapchainDisplayNativeHdrCreateInfoAMD = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA, eMetalSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT, ePhysicalDeviceFragmentDensityMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, @@ -5032,8 +5275,9 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, + eSurfaceProtectedCapabilitiesKHR = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, - ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, + ePhysicalDeviceBufferDeviceAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, eBufferDeviceAddressCreateInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT, @@ -5041,7 +5285,18 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceCooperativeMatrixFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, eCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV, ePhysicalDeviceCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, + ePhysicalDeviceCoverageReductionModeFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, + ePipelineCoverageReductionStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV, + eFramebufferMixedSamplesCombinationNV = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV, ePhysicalDeviceYcbcrImageArraysFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, + ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, + eSurfaceFullScreenExclusiveInfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT, + eSurfaceCapabilitiesFullScreenExclusiveEXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, + eSurfaceFullScreenExclusiveWin32InfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT, + eHeadlessSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT, + ePhysicalDeviceHostQueryResetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, + ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, + ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, @@ -5085,6 +5340,7 @@ namespace VULKAN_HPP_NAMESPACE eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR, ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, + ePhysicalDeviceVariablePointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, @@ -5101,7 +5357,8 @@ namespace VULKAN_HPP_NAMESPACE eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR, - eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR + eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR, + ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT }; VULKAN_HPP_INLINE std::string to_string( StructureType value ) @@ -5193,7 +5450,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eRenderPassMultiviewCreateInfo : return "RenderPassMultiviewCreateInfo"; case StructureType::ePhysicalDeviceMultiviewFeatures : return "PhysicalDeviceMultiviewFeatures"; case StructureType::ePhysicalDeviceMultiviewProperties : return "PhysicalDeviceMultiviewProperties"; - case StructureType::ePhysicalDeviceVariablePointerFeatures : return "PhysicalDeviceVariablePointerFeatures"; + case StructureType::ePhysicalDeviceVariablePointersFeatures : return "PhysicalDeviceVariablePointersFeatures"; case StructureType::eProtectedSubmitInfo : return "ProtectedSubmitInfo"; case StructureType::ePhysicalDeviceProtectedMemoryFeatures : return "PhysicalDeviceProtectedMemoryFeatures"; case StructureType::ePhysicalDeviceProtectedMemoryProperties : return "PhysicalDeviceProtectedMemoryProperties"; @@ -5221,7 +5478,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eExternalSemaphoreProperties : return "ExternalSemaphoreProperties"; case StructureType::ePhysicalDeviceMaintenance3Properties : return "PhysicalDeviceMaintenance3Properties"; case StructureType::eDescriptorSetLayoutSupport : return "DescriptorSetLayoutSupport"; - case StructureType::ePhysicalDeviceShaderDrawParameterFeatures : return "PhysicalDeviceShaderDrawParameterFeatures"; + case StructureType::ePhysicalDeviceShaderDrawParametersFeatures : return "PhysicalDeviceShaderDrawParametersFeatures"; case StructureType::eSwapchainCreateInfoKHR : return "SwapchainCreateInfoKHR"; case StructureType::ePresentInfoKHR : return "PresentInfoKHR"; case StructureType::eDeviceGroupPresentCapabilitiesKHR : return "DeviceGroupPresentCapabilitiesKHR"; @@ -5251,6 +5508,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT"; case StructureType::eImageViewHandleInfoNVX : return "ImageViewHandleInfoNVX"; case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD"; + case StructureType::eStreamDescriptorSurfaceCreateInfoGGP : return "StreamDescriptorSurfaceCreateInfoGGP"; case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV : return "PhysicalDeviceCornerSampledImageFeaturesNV"; case StructureType::eExternalMemoryImageCreateInfoNV : return "ExternalMemoryImageCreateInfoNV"; case StructureType::eExportMemoryAllocateInfoNV : return "ExportMemoryAllocateInfoNV"; @@ -5398,6 +5656,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT : return "PipelineVertexInputDivisorStateCreateInfoEXT"; case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT : return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT"; + case StructureType::ePresentFrameTokenGGP : return "PresentFrameTokenGGP"; + case StructureType::ePipelineCreationFeedbackCreateInfoEXT : return "PipelineCreationFeedbackCreateInfoEXT"; case StructureType::ePhysicalDeviceDriverPropertiesKHR : return "PhysicalDeviceDriverPropertiesKHR"; case StructureType::ePhysicalDeviceFloatControlsPropertiesKHR : return "PhysicalDeviceFloatControlsPropertiesKHR"; case StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR : return "PhysicalDeviceDepthStencilResolvePropertiesKHR"; @@ -5411,8 +5671,17 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV : return "PhysicalDeviceExclusiveScissorFeaturesNV"; case StructureType::eCheckpointDataNV : return "CheckpointDataNV"; case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV"; + case StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : return "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"; + case StructureType::eQueryPoolCreateInfoINTEL : return "QueryPoolCreateInfoINTEL"; + case StructureType::eInitializePerformanceApiInfoINTEL : return "InitializePerformanceApiInfoINTEL"; + case StructureType::ePerformanceMarkerInfoINTEL : return "PerformanceMarkerInfoINTEL"; + case StructureType::ePerformanceStreamMarkerInfoINTEL : return "PerformanceStreamMarkerInfoINTEL"; + case StructureType::ePerformanceOverrideInfoINTEL : return "PerformanceOverrideInfoINTEL"; + case StructureType::ePerformanceConfigurationAcquireInfoINTEL : return "PerformanceConfigurationAcquireInfoINTEL"; case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR : return "PhysicalDeviceVulkanMemoryModelFeaturesKHR"; case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT"; + case StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD : return "DisplayNativeHdrSurfaceCapabilitiesAMD"; + case StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD : return "SwapchainDisplayNativeHdrCreateInfoAMD"; case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA : return "ImagepipeSurfaceCreateInfoFUCHSIA"; case StructureType::eMetalSurfaceCreateInfoEXT : return "MetalSurfaceCreateInfoEXT"; case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT : return "PhysicalDeviceFragmentDensityMapFeaturesEXT"; @@ -5422,8 +5691,9 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT"; case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT"; case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT"; + case StructureType::eSurfaceProtectedCapabilitiesKHR : return "SurfaceProtectedCapabilitiesKHR"; case StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : return "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"; - case StructureType::ePhysicalDeviceBufferAddressFeaturesEXT : return "PhysicalDeviceBufferAddressFeaturesEXT"; + case StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT : return "PhysicalDeviceBufferDeviceAddressFeaturesEXT"; case StructureType::eBufferDeviceAddressInfoEXT : return "BufferDeviceAddressInfoEXT"; case StructureType::eBufferDeviceAddressCreateInfoEXT : return "BufferDeviceAddressCreateInfoEXT"; case StructureType::eImageStencilUsageCreateInfoEXT : return "ImageStencilUsageCreateInfoEXT"; @@ -5431,7 +5701,16 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV : return "PhysicalDeviceCooperativeMatrixFeaturesNV"; case StructureType::eCooperativeMatrixPropertiesNV : return "CooperativeMatrixPropertiesNV"; case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV : return "PhysicalDeviceCooperativeMatrixPropertiesNV"; + case StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV : return "PhysicalDeviceCoverageReductionModeFeaturesNV"; + case StructureType::ePipelineCoverageReductionStateCreateInfoNV : return "PipelineCoverageReductionStateCreateInfoNV"; + case StructureType::eFramebufferMixedSamplesCombinationNV : return "FramebufferMixedSamplesCombinationNV"; case StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT : return "PhysicalDeviceYcbcrImageArraysFeaturesEXT"; + case StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR : return "PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR"; + case StructureType::eSurfaceFullScreenExclusiveInfoEXT : return "SurfaceFullScreenExclusiveInfoEXT"; + case StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT : return "SurfaceCapabilitiesFullScreenExclusiveEXT"; + case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT : return "SurfaceFullScreenExclusiveWin32InfoEXT"; + case StructureType::eHeadlessSurfaceCreateInfoEXT : return "HeadlessSurfaceCreateInfoEXT"; + case StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT : return "PhysicalDeviceHostQueryResetFeaturesEXT"; default: return "invalid"; } } @@ -7841,6 +8120,21 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + enum class HeadlessSurfaceCreateFlagBitsEXT + {}; + + VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagBitsEXT ) + { + return "(void)"; + } + + using HeadlessSurfaceCreateFlagsEXT = Flags; + + VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagsEXT ) + { + return "{}"; + } + #ifdef VK_USE_PLATFORM_IOS_MVK enum class IOSSurfaceCreateFlagBitsMVK {}; @@ -8571,6 +8865,21 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineCoverageReductionStateCreateFlagBitsNV + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagBitsNV ) + { + return "(void)"; + } + + using PipelineCoverageReductionStateCreateFlagsNV = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagsNV ) + { + return "{}"; + } + enum class PipelineCoverageToColorStateCreateFlagBitsNV {}; @@ -8646,6 +8955,55 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + enum class PipelineCreationFeedbackFlagBitsEXT + { + eValid = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT, + eApplicationPipelineCacheHit = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT, + eBasePipelineAcceleration = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlagBitsEXT value ) + { + switch ( value ) + { + case PipelineCreationFeedbackFlagBitsEXT::eValid : return "Valid"; + case PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit : return "ApplicationPipelineCacheHit"; + case PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration : return "BasePipelineAcceleration"; + default: return "invalid"; + } + } + + using PipelineCreationFeedbackFlagsEXT = Flags; + + VULKAN_HPP_INLINE PipelineCreationFeedbackFlagsEXT operator|( PipelineCreationFeedbackFlagBitsEXT bit0, PipelineCreationFeedbackFlagBitsEXT bit1 ) + { + return PipelineCreationFeedbackFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE PipelineCreationFeedbackFlagsEXT operator~( PipelineCreationFeedbackFlagBitsEXT bits ) + { + return ~( PipelineCreationFeedbackFlagsEXT( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(PipelineCreationFeedbackFlagBitsEXT::eValid) | VkFlags(PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit) | VkFlags(PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlagsEXT value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & PipelineCreationFeedbackFlagBitsEXT::eValid ) result += "Valid | "; + if ( value & PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit ) result += "ApplicationPipelineCacheHit | "; + if ( value & PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration ) result += "BasePipelineAcceleration | "; + return "{ " + result.substr(0, result.size() - 3) + " }"; + } + enum class PipelineDepthStencilStateCreateFlagBits {}; @@ -9709,6 +10067,23 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } +#ifdef VK_USE_PLATFORM_GGP + enum class StreamDescriptorSurfaceCreateFlagBitsGGP + {}; + + VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP ) + { + return "(void)"; + } + + using StreamDescriptorSurfaceCreateFlagsGGP = Flags; + + VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_GGP*/ + enum class SubgroupFeatureFlagBits { eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, @@ -10379,6 +10754,15 @@ namespace VULKAN_HPP_NAMESPACE : SystemError( make_error_code( Result::eErrorInvalidDeviceAddressEXT ), message ) {} }; + class FullScreenExclusiveModeLostEXTError : public SystemError + { + public: + FullScreenExclusiveModeLostEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {} + FullScreenExclusiveModeLostEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {} + }; + VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) { @@ -10408,6 +10792,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorFragmentationEXT: throw FragmentationEXTError( message ); case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError( message ); case Result::eErrorInvalidDeviceAddressEXT: throw InvalidDeviceAddressEXTError( message ); + case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message ); default: throw SystemError( make_error_code( result ) ); } } @@ -10659,6 +11044,7 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayModeParametersKHR; struct DisplayModeProperties2KHR; struct DisplayModePropertiesKHR; + struct DisplayNativeHdrSurfaceCapabilitiesAMD; struct DisplayPlaneCapabilities2KHR; struct DisplayPlaneCapabilitiesKHR; struct DisplayPlaneInfo2KHR; @@ -10726,12 +11112,14 @@ namespace VULKAN_HPP_NAMESPACE struct FormatProperties2; using FormatProperties2KHR = FormatProperties2; struct FramebufferCreateInfo; + struct FramebufferMixedSamplesCombinationNV; struct GeometryAABBNV; struct GeometryDataNV; struct GeometryNV; struct GeometryTrianglesNV; struct GraphicsPipelineCreateInfo; struct HdrMetadataEXT; + struct HeadlessSurfaceCreateInfoEXT; #ifdef VK_USE_PLATFORM_IOS_MVK struct IOSSurfaceCreateInfoMVK; #endif /*VK_USE_PLATFORM_IOS_MVK*/ @@ -10788,6 +11176,7 @@ namespace VULKAN_HPP_NAMESPACE struct IndirectCommandsLayoutCreateInfoNVX; struct IndirectCommandsLayoutTokenNVX; struct IndirectCommandsTokenNVX; + struct InitializePerformanceApiInfoINTEL; struct InputAttachmentAspectReference; using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; struct InstanceCreateInfo; @@ -10836,19 +11225,27 @@ namespace VULKAN_HPP_NAMESPACE struct Offset2D; struct Offset3D; struct PastPresentationTimingGOOGLE; + struct PerformanceConfigurationAcquireInfoINTEL; + struct PerformanceMarkerInfoINTEL; + struct PerformanceOverrideInfoINTEL; + struct PerformanceStreamMarkerInfoINTEL; + union PerformanceValueDataINTEL; + struct PerformanceValueINTEL; struct PhysicalDevice16BitStorageFeatures; using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; struct PhysicalDevice8BitStorageFeaturesKHR; struct PhysicalDeviceASTCDecodeFeaturesEXT; struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT; struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT; - struct PhysicalDeviceBufferAddressFeaturesEXT; + struct PhysicalDeviceBufferDeviceAddressFeaturesEXT; + using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; struct PhysicalDeviceComputeShaderDerivativesFeaturesNV; struct PhysicalDeviceConditionalRenderingFeaturesEXT; struct PhysicalDeviceConservativeRasterizationPropertiesEXT; struct PhysicalDeviceCooperativeMatrixFeaturesNV; struct PhysicalDeviceCooperativeMatrixPropertiesNV; struct PhysicalDeviceCornerSampledImageFeaturesNV; + struct PhysicalDeviceCoverageReductionModeFeaturesNV; struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; struct PhysicalDeviceDepthClipEnableFeaturesEXT; struct PhysicalDeviceDepthStencilResolvePropertiesKHR; @@ -10876,6 +11273,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV; struct PhysicalDeviceGroupProperties; using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; + struct PhysicalDeviceHostQueryResetFeaturesEXT; struct PhysicalDeviceIDProperties; using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; struct PhysicalDeviceImageDrmFormatModifierInfoEXT; @@ -10917,8 +11315,10 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceScalarBlockLayoutFeaturesEXT; struct PhysicalDeviceShaderAtomicInt64FeaturesKHR; struct PhysicalDeviceShaderCorePropertiesAMD; - struct PhysicalDeviceShaderDrawParameterFeatures; + struct PhysicalDeviceShaderDrawParametersFeatures; + using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; struct PhysicalDeviceShaderImageFootprintFeaturesNV; + struct PhysicalDeviceShaderIntegerFunctions2INTEL; struct PhysicalDeviceShadingRateImageFeaturesNV; struct PhysicalDeviceShadingRateImagePropertiesNV; struct PhysicalDeviceSparseImageFormatInfo2; @@ -10928,8 +11328,11 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceSurfaceInfo2KHR; struct PhysicalDeviceTransformFeedbackFeaturesEXT; struct PhysicalDeviceTransformFeedbackPropertiesEXT; - struct PhysicalDeviceVariablePointerFeatures; - using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointerFeatures; + struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; + struct PhysicalDeviceVariablePointersFeatures; + using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; + using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; + using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures; struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT; struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT; struct PhysicalDeviceVulkanMemoryModelFeaturesKHR; @@ -10939,7 +11342,10 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineColorBlendAttachmentState; struct PipelineColorBlendStateCreateInfo; struct PipelineCoverageModulationStateCreateInfoNV; + struct PipelineCoverageReductionStateCreateInfoNV; struct PipelineCoverageToColorStateCreateInfoNV; + struct PipelineCreationFeedbackCreateInfoEXT; + struct PipelineCreationFeedbackEXT; struct PipelineDepthStencilStateCreateInfo; struct PipelineDiscardRectangleStateCreateInfoEXT; struct PipelineDynamicStateCreateInfo; @@ -10965,6 +11371,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineViewportStateCreateInfo; struct PipelineViewportSwizzleStateCreateInfoNV; struct PipelineViewportWScalingStateCreateInfoNV; +#ifdef VK_USE_PLATFORM_GGP + struct PresentFrameTokenGGP; +#endif /*VK_USE_PLATFORM_GGP*/ struct PresentInfoKHR; struct PresentRegionKHR; struct PresentRegionsKHR; @@ -10973,6 +11382,7 @@ namespace VULKAN_HPP_NAMESPACE struct ProtectedSubmitInfo; struct PushConstantRange; struct QueryPoolCreateInfo; + struct QueryPoolCreateInfoINTEL; struct QueueFamilyCheckpointPropertiesNV; struct QueueFamilyProperties; struct QueueFamilyProperties2; @@ -11026,6 +11436,9 @@ namespace VULKAN_HPP_NAMESPACE struct SpecializationInfo; struct SpecializationMapEntry; struct StencilOpState; +#ifdef VK_USE_PLATFORM_GGP + struct StreamDescriptorSurfaceCreateInfoGGP; +#endif /*VK_USE_PLATFORM_GGP*/ struct SubmitInfo; struct SubpassBeginInfoKHR; struct SubpassDependency; @@ -11038,11 +11451,22 @@ namespace VULKAN_HPP_NAMESPACE struct SubresourceLayout; struct SurfaceCapabilities2EXT; struct SurfaceCapabilities2KHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceCapabilitiesFullScreenExclusiveEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SurfaceCapabilitiesKHR; struct SurfaceFormat2KHR; struct SurfaceFormatKHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceFullScreenExclusiveInfoEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceFullScreenExclusiveWin32InfoEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct SurfaceProtectedCapabilitiesKHR; struct SwapchainCounterCreateInfoEXT; struct SwapchainCreateInfoKHR; + struct SwapchainDisplayNativeHdrCreateInfoAMD; struct TextureLODGatherFormatPropertiesAMD; struct ValidationCacheCreateInfoEXT; struct ValidationFeaturesEXT; @@ -11527,6 +11951,70 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); + class PerformanceConfigurationINTEL + { + public: + VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() + : m_performanceConfigurationINTEL(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) + : m_performanceConfigurationINTEL(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) + : m_performanceConfigurationINTEL( performanceConfigurationINTEL ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + PerformanceConfigurationINTEL & operator=(VkPerformanceConfigurationINTEL performanceConfigurationINTEL) + { + m_performanceConfigurationINTEL = performanceConfigurationINTEL; + return *this; + } +#endif + + PerformanceConfigurationINTEL & operator=( std::nullptr_t ) + { + m_performanceConfigurationINTEL = VK_NULL_HANDLE; + return *this; + } + + bool operator==( PerformanceConfigurationINTEL const & rhs ) const + { + return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL; + } + + bool operator!=(PerformanceConfigurationINTEL const & rhs ) const + { + return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL; + } + + bool operator<(PerformanceConfigurationINTEL const & rhs ) const + { + return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const + { + return m_performanceConfigurationINTEL; + } + + explicit operator bool() const + { + return m_performanceConfigurationINTEL != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_performanceConfigurationINTEL == VK_NULL_HANDLE; + } + + private: + VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL; + }; + static_assert( sizeof( PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), "handle and wrapper have different size!" ); + class QueryPool { public: @@ -12576,6 +13064,27 @@ namespace VULKAN_HPP_NAMESPACE template void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const; + template + Result setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -13667,6 +14176,14 @@ namespace VULKAN_HPP_NAMESPACE Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -13806,6 +14323,16 @@ namespace VULKAN_HPP_NAMESPACE return m_device < rhs.m_device; } +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -13820,6 +14347,13 @@ namespace VULKAN_HPP_NAMESPACE ResultValue acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + Result acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -14847,6 +15381,15 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -15043,6 +15586,13 @@ namespace VULKAN_HPP_NAMESPACE typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + Result getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, PerformanceValueINTEL* pValue, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -15165,6 +15715,13 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template + Result initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -15214,6 +15771,24 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy pObjectTableEntries, ArrayProxy objectIndices, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const; @@ -15245,6 +15820,9 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType::type resetFences( ArrayProxy fences, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + void resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const; + template Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -15274,12 +15852,18 @@ namespace VULKAN_HPP_NAMESPACE void setHdrMetadataEXT( ArrayProxy swapchains, ArrayProxy metadata, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + void setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d = Dispatch() ) const; + template void trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const; template void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const; + template + void uninitializePerformanceApiINTEL(Dispatch const &d = Dispatch() ) const; + template void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const; @@ -15842,6 +16426,15 @@ namespace VULKAN_HPP_NAMESPACE std::vector getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + Result getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getSupportedFramebufferMixedSamplesCombinationsNV(Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getSupportedFramebufferMixedSamplesCombinationsNV(Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -15883,6 +16476,17 @@ namespace VULKAN_HPP_NAMESPACE typename ResultValueType>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -16066,6 +16670,17 @@ namespace VULKAN_HPP_NAMESPACE template typename ResultValueType>::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + typename ResultValueType>::type createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VK_USE_PLATFORM_IOS_MVK @@ -16120,6 +16735,19 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + template + Result createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + typename ResultValueType>::type createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_GGP*/ + #ifdef VK_USE_PLATFORM_VI_NN template Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; @@ -19891,7 +20519,7 @@ namespace VULKAN_HPP_NAMESPACE struct BufferDeviceAddressCreateInfoEXT { - BufferDeviceAddressCreateInfoEXT( DeviceSize deviceAddress_ = 0 ) + BufferDeviceAddressCreateInfoEXT( DeviceAddress deviceAddress_ = 0 ) : deviceAddress( deviceAddress_ ) {} @@ -19912,7 +20540,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceSize deviceAddress_ ) + BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ ) { deviceAddress = deviceAddress_; return *this; @@ -19945,7 +20573,7 @@ namespace VULKAN_HPP_NAMESPACE public: const void* pNext = nullptr; - DeviceSize deviceAddress; + DeviceAddress deviceAddress; }; static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" ); @@ -26654,6 +27282,39 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" ); + struct DisplayNativeHdrSurfaceCapabilitiesAMD + { + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() + { + return *reinterpret_cast( this ); + } + + bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( localDimmingSupport == rhs.localDimmingSupport ); + } + + bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; + + public: + void* pNext = nullptr; + Bool32 localDimmingSupport; + }; + static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" ); + struct DisplayPlaneCapabilitiesKHR { operator VkDisplayPlaneCapabilitiesKHR const&() const @@ -29031,6 +29692,45 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" ); + struct FramebufferMixedSamplesCombinationNV + { + operator VkFramebufferMixedSamplesCombinationNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferMixedSamplesCombinationNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( FramebufferMixedSamplesCombinationNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( coverageReductionMode == rhs.coverageReductionMode ) + && ( rasterizationSamples == rhs.rasterizationSamples ) + && ( depthStencilSamples == rhs.depthStencilSamples ) + && ( colorSamples == rhs.colorSamples ); + } + + bool operator!=( FramebufferMixedSamplesCombinationNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV; + + public: + void* pNext = nullptr; + CoverageReductionModeNV coverageReductionMode; + SampleCountFlagBits rasterizationSamples; + SampleCountFlags depthStencilSamples; + SampleCountFlags colorSamples; + }; + static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "struct and wrapper have different size!" ); + struct VertexInputBindingDescription { VertexInputBindingDescription( uint32_t binding_ = 0, @@ -30874,6 +31574,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); + struct HeadlessSurfaceCreateInfoEXT + { + HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateFlagsEXT flags_ = HeadlessSurfaceCreateFlagsEXT() ) + : flags( flags_ ) + {} + + HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( HeadlessSurfaceCreateInfoEXT ) ); + } + + HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( HeadlessSurfaceCreateInfoEXT ) ); + return *this; + } + + HeadlessSurfaceCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + HeadlessSurfaceCreateInfoEXT & setFlags( HeadlessSurfaceCreateFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + operator VkHeadlessSurfaceCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkHeadlessSurfaceCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( HeadlessSurfaceCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ); + } + + bool operator!=( HeadlessSurfaceCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT; + + public: + const void* pNext = nullptr; + HeadlessSurfaceCreateFlagsEXT flags; + }; + static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "struct and wrapper have different size!" ); + #ifdef VK_USE_PLATFORM_IOS_MVK struct IOSSurfaceCreateInfoMVK { @@ -33504,6 +34264,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" ); + struct InitializePerformanceApiInfoINTEL + { + InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr ) + : pUserData( pUserData_ ) + {} + + InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( InitializePerformanceApiInfoINTEL ) ); + } + + InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( InitializePerformanceApiInfoINTEL ) ); + return *this; + } + + InitializePerformanceApiInfoINTEL & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + InitializePerformanceApiInfoINTEL & setPUserData( void* pUserData_ ) + { + pUserData = pUserData_; + return *this; + } + + operator VkInitializePerformanceApiInfoINTEL const&() const + { + return *reinterpret_cast( this ); + } + + operator VkInitializePerformanceApiInfoINTEL &() + { + return *reinterpret_cast( this ); + } + + bool operator==( InitializePerformanceApiInfoINTEL const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pUserData == rhs.pUserData ); + } + + bool operator!=( InitializePerformanceApiInfoINTEL const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL; + + public: + const void* pNext = nullptr; + void* pUserData; + }; + static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "struct and wrapper have different size!" ); + struct InputAttachmentAspectReference { InputAttachmentAspectReference( uint32_t subpass_ = 0, @@ -35406,6 +36226,389 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" ); + struct PerformanceConfigurationAcquireInfoINTEL + { + PerformanceConfigurationAcquireInfoINTEL( PerformanceConfigurationTypeINTEL type_ = PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) + : type( type_ ) + {} + + PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceConfigurationAcquireInfoINTEL ) ); + } + + PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceConfigurationAcquireInfoINTEL ) ); + return *this; + } + + PerformanceConfigurationAcquireInfoINTEL & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PerformanceConfigurationAcquireInfoINTEL & setType( PerformanceConfigurationTypeINTEL type_ ) + { + type = type_; + return *this; + } + + operator VkPerformanceConfigurationAcquireInfoINTEL const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceConfigurationAcquireInfoINTEL &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PerformanceConfigurationAcquireInfoINTEL const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( type == rhs.type ); + } + + bool operator!=( PerformanceConfigurationAcquireInfoINTEL const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; + + public: + const void* pNext = nullptr; + PerformanceConfigurationTypeINTEL type; + }; + static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "struct and wrapper have different size!" ); + + struct PerformanceMarkerInfoINTEL + { + PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 ) + : marker( marker_ ) + {} + + PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceMarkerInfoINTEL ) ); + } + + PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceMarkerInfoINTEL ) ); + return *this; + } + + PerformanceMarkerInfoINTEL & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PerformanceMarkerInfoINTEL & setMarker( uint64_t marker_ ) + { + marker = marker_; + return *this; + } + + operator VkPerformanceMarkerInfoINTEL const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceMarkerInfoINTEL &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PerformanceMarkerInfoINTEL const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( marker == rhs.marker ); + } + + bool operator!=( PerformanceMarkerInfoINTEL const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePerformanceMarkerInfoINTEL; + + public: + const void* pNext = nullptr; + uint64_t marker; + }; + static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "struct and wrapper have different size!" ); + + struct PerformanceOverrideInfoINTEL + { + PerformanceOverrideInfoINTEL( PerformanceOverrideTypeINTEL type_ = PerformanceOverrideTypeINTEL::eNullHardware, + Bool32 enable_ = 0, + uint64_t parameter_ = 0 ) + : type( type_ ) + , enable( enable_ ) + , parameter( parameter_ ) + {} + + PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceOverrideInfoINTEL ) ); + } + + PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceOverrideInfoINTEL ) ); + return *this; + } + + PerformanceOverrideInfoINTEL & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PerformanceOverrideInfoINTEL & setType( PerformanceOverrideTypeINTEL type_ ) + { + type = type_; + return *this; + } + + PerformanceOverrideInfoINTEL & setEnable( Bool32 enable_ ) + { + enable = enable_; + return *this; + } + + PerformanceOverrideInfoINTEL & setParameter( uint64_t parameter_ ) + { + parameter = parameter_; + return *this; + } + + operator VkPerformanceOverrideInfoINTEL const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceOverrideInfoINTEL &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PerformanceOverrideInfoINTEL const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( type == rhs.type ) + && ( enable == rhs.enable ) + && ( parameter == rhs.parameter ); + } + + bool operator!=( PerformanceOverrideInfoINTEL const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePerformanceOverrideInfoINTEL; + + public: + const void* pNext = nullptr; + PerformanceOverrideTypeINTEL type; + Bool32 enable; + uint64_t parameter; + }; + static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "struct and wrapper have different size!" ); + + struct PerformanceStreamMarkerInfoINTEL + { + PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 ) + : marker( marker_ ) + {} + + PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceStreamMarkerInfoINTEL ) ); + } + + PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceStreamMarkerInfoINTEL ) ); + return *this; + } + + PerformanceStreamMarkerInfoINTEL & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PerformanceStreamMarkerInfoINTEL & setMarker( uint32_t marker_ ) + { + marker = marker_; + return *this; + } + + operator VkPerformanceStreamMarkerInfoINTEL const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceStreamMarkerInfoINTEL &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PerformanceStreamMarkerInfoINTEL const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( marker == rhs.marker ); + } + + bool operator!=( PerformanceStreamMarkerInfoINTEL const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL; + + public: + const void* pNext = nullptr; + uint32_t marker; + }; + static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "struct and wrapper have different size!" ); + + union PerformanceValueDataINTEL + { + PerformanceValueDataINTEL( uint32_t value32_ = 0 ) + { + value32 = value32_; + } + + PerformanceValueDataINTEL( uint64_t value64_ ) + { + value64 = value64_; + } + + PerformanceValueDataINTEL( float valueFloat_ ) + { + valueFloat = valueFloat_; + } + + PerformanceValueDataINTEL( const char* valueString_ ) + { + valueString = valueString_; + } + + + PerformanceValueDataINTEL & setValue32( uint32_t value32_ ) + { + value32 = value32_; + return *this; + } + + PerformanceValueDataINTEL & setValue64( uint64_t value64_ ) + { + value64 = value64_; + return *this; + } + + PerformanceValueDataINTEL & setValueFloat( float valueFloat_ ) + { + valueFloat = valueFloat_; + return *this; + } + + PerformanceValueDataINTEL & setValueBool( Bool32 valueBool_ ) + { + valueBool = valueBool_; + return *this; + } + + PerformanceValueDataINTEL & setValueString( const char* valueString_ ) + { + valueString = valueString_; + return *this; + } + operator VkPerformanceValueDataINTEL const&() const + { + return *reinterpret_cast(this); + } + + operator VkPerformanceValueDataINTEL &() + { + return *reinterpret_cast(this); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + uint32_t value32; + uint64_t value64; + float valueFloat; + Bool32 valueBool; + const char* valueString; +#else + uint32_t value32; + uint64_t value64; + float valueFloat; + VkBool32 valueBool; + const char* valueString; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + + struct PerformanceValueINTEL + { + PerformanceValueINTEL( PerformanceValueTypeINTEL type_ = PerformanceValueTypeINTEL::eUint32, + PerformanceValueDataINTEL data_ = PerformanceValueDataINTEL() ) + : type( type_ ) + , data( data_ ) + {} + + PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceValueINTEL ) ); + } + + PerformanceValueINTEL& operator=( VkPerformanceValueINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PerformanceValueINTEL ) ); + return *this; + } + + PerformanceValueINTEL & setType( PerformanceValueTypeINTEL type_ ) + { + type = type_; + return *this; + } + + PerformanceValueINTEL & setData( PerformanceValueDataINTEL data_ ) + { + data = data_; + return *this; + } + + operator VkPerformanceValueINTEL const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceValueINTEL &() + { + return *reinterpret_cast( this ); + } + + PerformanceValueTypeINTEL type; + PerformanceValueDataINTEL data; + }; + static_assert( sizeof( PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), "struct and wrapper have different size!" ); + struct PhysicalDevice16BitStorageFeatures { PhysicalDevice16BitStorageFeatures( Bool32 storageBuffer16BitAccess_ = 0, @@ -35739,62 +36942,62 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); - struct PhysicalDeviceBufferAddressFeaturesEXT + struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { - PhysicalDeviceBufferAddressFeaturesEXT( Bool32 bufferDeviceAddress_ = 0, - Bool32 bufferDeviceAddressCaptureReplay_ = 0, - Bool32 bufferDeviceAddressMultiDevice_ = 0 ) + PhysicalDeviceBufferDeviceAddressFeaturesEXT( Bool32 bufferDeviceAddress_ = 0, + Bool32 bufferDeviceAddressCaptureReplay_ = 0, + Bool32 bufferDeviceAddressMultiDevice_ = 0 ) : bufferDeviceAddress( bufferDeviceAddress_ ) , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ) , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ ) {} - PhysicalDeviceBufferAddressFeaturesEXT( VkPhysicalDeviceBufferAddressFeaturesEXT const & rhs ) + PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) ); } - PhysicalDeviceBufferAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferAddressFeaturesEXT const & rhs ) + PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) ); return *this; } - PhysicalDeviceBufferAddressFeaturesEXT & setPNext( void* pNext_ ) + PhysicalDeviceBufferDeviceAddressFeaturesEXT & setPNext( void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceBufferAddressFeaturesEXT & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) + PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) { bufferDeviceAddress = bufferDeviceAddress_; return *this; } - PhysicalDeviceBufferAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) + PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) { bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; return *this; } - PhysicalDeviceBufferAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) + PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) { bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; return *this; } - operator VkPhysicalDeviceBufferAddressFeaturesEXT const&() const + operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const&() const { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceBufferAddressFeaturesEXT &() + operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - bool operator==( PhysicalDeviceBufferAddressFeaturesEXT const& rhs ) const + bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -35803,13 +37006,13 @@ namespace VULKAN_HPP_NAMESPACE && ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); } - bool operator!=( PhysicalDeviceBufferAddressFeaturesEXT const& rhs ) const + bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::ePhysicalDeviceBufferAddressFeaturesEXT; + StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; public: void* pNext = nullptr; @@ -35817,7 +37020,7 @@ namespace VULKAN_HPP_NAMESPACE Bool32 bufferDeviceAddressCaptureReplay; Bool32 bufferDeviceAddressMultiDevice; }; - static_assert( sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferAddressFeaturesEXT ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "struct and wrapper have different size!" ); struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { @@ -36171,6 +37374,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" ); + struct PhysicalDeviceCoverageReductionModeFeaturesNV + { + PhysicalDeviceCoverageReductionModeFeaturesNV( Bool32 coverageReductionMode_ = 0 ) + : coverageReductionMode( coverageReductionMode_ ) + {} + + PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) ); + } + + PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) ); + return *this; + } + + PhysicalDeviceCoverageReductionModeFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceCoverageReductionModeFeaturesNV & setCoverageReductionMode( Bool32 coverageReductionMode_ ) + { + coverageReductionMode = coverageReductionMode_; + return *this; + } + + operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( coverageReductionMode == rhs.coverageReductionMode ); + } + + bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 coverageReductionMode; + }; + static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "struct and wrapper have different size!" ); + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( Bool32 dedicatedAllocationImageAliasing_ = 0 ) @@ -37448,6 +38711,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" ); + struct PhysicalDeviceHostQueryResetFeaturesEXT + { + PhysicalDeviceHostQueryResetFeaturesEXT( Bool32 hostQueryReset_ = 0 ) + : hostQueryReset( hostQueryReset_ ) + {} + + PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) ); + } + + PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceHostQueryResetFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceHostQueryResetFeaturesEXT & setHostQueryReset( Bool32 hostQueryReset_ ) + { + hostQueryReset = hostQueryReset_; + return *this; + } + + operator VkPhysicalDeviceHostQueryResetFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostQueryResetFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceHostQueryResetFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( hostQueryReset == rhs.hostQueryReset ); + } + + bool operator!=( PhysicalDeviceHostQueryResetFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 hostQueryReset; + }; + static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "struct and wrapper have different size!" ); + struct PhysicalDeviceIDProperties { operator VkPhysicalDeviceIDProperties const&() const @@ -39295,65 +40618,65 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" ); - struct PhysicalDeviceShaderDrawParameterFeatures + struct PhysicalDeviceShaderDrawParametersFeatures { - PhysicalDeviceShaderDrawParameterFeatures( Bool32 shaderDrawParameters_ = 0 ) + PhysicalDeviceShaderDrawParametersFeatures( Bool32 shaderDrawParameters_ = 0 ) : shaderDrawParameters( shaderDrawParameters_ ) {} - PhysicalDeviceShaderDrawParameterFeatures( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs ) + PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParametersFeatures ) ); } - PhysicalDeviceShaderDrawParameterFeatures& operator=( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs ) + PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParametersFeatures ) ); return *this; } - PhysicalDeviceShaderDrawParameterFeatures & setPNext( void* pNext_ ) + PhysicalDeviceShaderDrawParametersFeatures & setPNext( void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceShaderDrawParameterFeatures & setShaderDrawParameters( Bool32 shaderDrawParameters_ ) + PhysicalDeviceShaderDrawParametersFeatures & setShaderDrawParameters( Bool32 shaderDrawParameters_ ) { shaderDrawParameters = shaderDrawParameters_; return *this; } - operator VkPhysicalDeviceShaderDrawParameterFeatures const&() const + operator VkPhysicalDeviceShaderDrawParametersFeatures const&() const { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderDrawParameterFeatures &() + operator VkPhysicalDeviceShaderDrawParametersFeatures &() { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - bool operator==( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const + bool operator==( PhysicalDeviceShaderDrawParametersFeatures const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters ); } - bool operator!=( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const + bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::ePhysicalDeviceShaderDrawParameterFeatures; + StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; public: void* pNext = nullptr; Bool32 shaderDrawParameters; }; - static_assert( sizeof( PhysicalDeviceShaderDrawParameterFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParameterFeatures ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "struct and wrapper have different size!" ); struct PhysicalDeviceShaderImageFootprintFeaturesNV { @@ -39415,6 +40738,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" ); + struct PhysicalDeviceShaderIntegerFunctions2INTEL + { + PhysicalDeviceShaderIntegerFunctions2INTEL( Bool32 shaderIntegerFunctions2_ = 0 ) + : shaderIntegerFunctions2( shaderIntegerFunctions2_ ) + {} + + PhysicalDeviceShaderIntegerFunctions2INTEL( VkPhysicalDeviceShaderIntegerFunctions2INTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderIntegerFunctions2INTEL ) ); + } + + PhysicalDeviceShaderIntegerFunctions2INTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2INTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderIntegerFunctions2INTEL ) ); + return *this; + } + + PhysicalDeviceShaderIntegerFunctions2INTEL & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceShaderIntegerFunctions2INTEL & setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ ) + { + shaderIntegerFunctions2 = shaderIntegerFunctions2_; + return *this; + } + + operator VkPhysicalDeviceShaderIntegerFunctions2INTEL const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerFunctions2INTEL &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceShaderIntegerFunctions2INTEL const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 ); + } + + bool operator!=( PhysicalDeviceShaderIntegerFunctions2INTEL const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + + public: + void* pNext = nullptr; + Bool32 shaderIntegerFunctions2; + }; + static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2INTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2INTEL ), "struct and wrapper have different size!" ); + struct PhysicalDeviceShadingRateImageFeaturesNV { PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = 0, @@ -39842,54 +41225,114 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" ); - struct PhysicalDeviceVariablePointerFeatures + struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR { - PhysicalDeviceVariablePointerFeatures( Bool32 variablePointersStorageBuffer_ = 0, - Bool32 variablePointers_ = 0 ) - : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) - , variablePointers( variablePointers_ ) + PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( Bool32 uniformBufferStandardLayout_ = 0 ) + : uniformBufferStandardLayout( uniformBufferStandardLayout_ ) {} - PhysicalDeviceVariablePointerFeatures( VkPhysicalDeviceVariablePointerFeatures const & rhs ) + PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) ); } - PhysicalDeviceVariablePointerFeatures& operator=( VkPhysicalDeviceVariablePointerFeatures const & rhs ) + PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) ); return *this; } - PhysicalDeviceVariablePointerFeatures & setPNext( void* pNext_ ) + PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & setPNext( void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceVariablePointerFeatures & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) + PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) + { + uniformBufferStandardLayout = uniformBufferStandardLayout_; + return *this; + } + + operator VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ); + } + + bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; + + public: + void* pNext = nullptr; + Bool32 uniformBufferStandardLayout; + }; + static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceVariablePointersFeatures + { + PhysicalDeviceVariablePointersFeatures( Bool32 variablePointersStorageBuffer_ = 0, + Bool32 variablePointers_ = 0 ) + : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) + , variablePointers( variablePointers_ ) + {} + + PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointersFeatures ) ); + } + + PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointersFeatures ) ); + return *this; + } + + PhysicalDeviceVariablePointersFeatures & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceVariablePointersFeatures & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) { variablePointersStorageBuffer = variablePointersStorageBuffer_; return *this; } - PhysicalDeviceVariablePointerFeatures & setVariablePointers( Bool32 variablePointers_ ) + PhysicalDeviceVariablePointersFeatures & setVariablePointers( Bool32 variablePointers_ ) { variablePointers = variablePointers_; return *this; } - operator VkPhysicalDeviceVariablePointerFeatures const&() const + operator VkPhysicalDeviceVariablePointersFeatures const&() const { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVariablePointerFeatures &() + operator VkPhysicalDeviceVariablePointersFeatures &() { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - bool operator==( PhysicalDeviceVariablePointerFeatures const& rhs ) const + bool operator==( PhysicalDeviceVariablePointersFeatures const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -39897,20 +41340,20 @@ namespace VULKAN_HPP_NAMESPACE && ( variablePointers == rhs.variablePointers ); } - bool operator!=( PhysicalDeviceVariablePointerFeatures const& rhs ) const + bool operator!=( PhysicalDeviceVariablePointersFeatures const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeatures; + StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures; public: void* pNext = nullptr; Bool32 variablePointersStorageBuffer; Bool32 variablePointers; }; - static_assert( sizeof( PhysicalDeviceVariablePointerFeatures ) == sizeof( VkPhysicalDeviceVariablePointerFeatures ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "struct and wrapper have different size!" ); struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { @@ -40415,6 +41858,76 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" ); + struct PipelineCoverageReductionStateCreateInfoNV + { + PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateFlagsNV flags_ = PipelineCoverageReductionStateCreateFlagsNV(), + CoverageReductionModeNV coverageReductionMode_ = CoverageReductionModeNV::eMerge ) + : flags( flags_ ) + , coverageReductionMode( coverageReductionMode_ ) + {} + + PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageReductionStateCreateInfoNV ) ); + } + + PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageReductionStateCreateInfoNV ) ); + return *this; + } + + PipelineCoverageReductionStateCreateInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCoverageReductionStateCreateInfoNV & setFlags( PipelineCoverageReductionStateCreateFlagsNV flags_ ) + { + flags = flags_; + return *this; + } + + PipelineCoverageReductionStateCreateInfoNV & setCoverageReductionMode( CoverageReductionModeNV coverageReductionMode_ ) + { + coverageReductionMode = coverageReductionMode_; + return *this; + } + + operator VkPipelineCoverageReductionStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageReductionStateCreateInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineCoverageReductionStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( coverageReductionMode == rhs.coverageReductionMode ); + } + + bool operator!=( PipelineCoverageReductionStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; + + public: + const void* pNext = nullptr; + PipelineCoverageReductionStateCreateFlagsNV flags; + CoverageReductionModeNV coverageReductionMode; + }; + static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "struct and wrapper have different size!" ); + struct PipelineCoverageToColorStateCreateInfoNV { PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), @@ -40495,6 +42008,114 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); + struct PipelineCreationFeedbackEXT + { + operator VkPipelineCreationFeedbackEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreationFeedbackEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineCreationFeedbackEXT const& rhs ) const + { + return ( flags == rhs.flags ) + && ( duration == rhs.duration ); + } + + bool operator!=( PipelineCreationFeedbackEXT const& rhs ) const + { + return !operator==( rhs ); + } + + PipelineCreationFeedbackFlagsEXT flags; + uint64_t duration; + }; + static_assert( sizeof( PipelineCreationFeedbackEXT ) == sizeof( VkPipelineCreationFeedbackEXT ), "struct and wrapper have different size!" ); + + struct PipelineCreationFeedbackCreateInfoEXT + { + PipelineCreationFeedbackCreateInfoEXT( PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr, + uint32_t pipelineStageCreationFeedbackCount_ = 0, + PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr ) + : pPipelineCreationFeedback( pPipelineCreationFeedback_ ) + , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ ) + , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ ) + {} + + PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCreationFeedbackCreateInfoEXT ) ); + } + + PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCreationFeedbackCreateInfoEXT ) ); + return *this; + } + + PipelineCreationFeedbackCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCreationFeedbackCreateInfoEXT & setPPipelineCreationFeedback( PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ ) + { + pPipelineCreationFeedback = pPipelineCreationFeedback_; + return *this; + } + + PipelineCreationFeedbackCreateInfoEXT & setPipelineStageCreationFeedbackCount( uint32_t pipelineStageCreationFeedbackCount_ ) + { + pipelineStageCreationFeedbackCount = pipelineStageCreationFeedbackCount_; + return *this; + } + + PipelineCreationFeedbackCreateInfoEXT & setPPipelineStageCreationFeedbacks( PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ ) + { + pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks_; + return *this; + } + + operator VkPipelineCreationFeedbackCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreationFeedbackCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineCreationFeedbackCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) + && ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) + && ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks ); + } + + bool operator!=( PipelineCreationFeedbackCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT; + + public: + const void* pNext = nullptr; + PipelineCreationFeedbackEXT* pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks; + }; + static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "struct and wrapper have different size!" ); + struct PipelineDiscardRectangleStateCreateInfoEXT { PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), @@ -41930,6 +43551,68 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" ); +#ifdef VK_USE_PLATFORM_GGP + struct PresentFrameTokenGGP + { + PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 ) + : frameToken( frameToken_ ) + {} + + PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentFrameTokenGGP ) ); + } + + PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentFrameTokenGGP ) ); + return *this; + } + + PresentFrameTokenGGP & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PresentFrameTokenGGP & setFrameToken( GgpFrameToken frameToken_ ) + { + frameToken = frameToken_; + return *this; + } + + operator VkPresentFrameTokenGGP const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPresentFrameTokenGGP &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PresentFrameTokenGGP const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( frameToken == rhs.frameToken ); + } + + bool operator!=( PresentFrameTokenGGP const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePresentFrameTokenGGP; + + public: + const void* pNext = nullptr; + GgpFrameToken frameToken; + }; + static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_GGP*/ + struct PresentInfoKHR { PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, @@ -42518,6 +44201,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); + struct QueryPoolCreateInfoINTEL + { + QueryPoolCreateInfoINTEL( QueryPoolSamplingModeINTEL performanceCountersSampling_ = QueryPoolSamplingModeINTEL::eManual ) + : performanceCountersSampling( performanceCountersSampling_ ) + {} + + QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( QueryPoolCreateInfoINTEL ) ); + } + + QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs ) + { + memcpy( this, &rhs, sizeof( QueryPoolCreateInfoINTEL ) ); + return *this; + } + + QueryPoolCreateInfoINTEL & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + QueryPoolCreateInfoINTEL & setPerformanceCountersSampling( QueryPoolSamplingModeINTEL performanceCountersSampling_ ) + { + performanceCountersSampling = performanceCountersSampling_; + return *this; + } + + operator VkQueryPoolCreateInfoINTEL const&() const + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolCreateInfoINTEL &() + { + return *reinterpret_cast( this ); + } + + bool operator==( QueryPoolCreateInfoINTEL const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( performanceCountersSampling == rhs.performanceCountersSampling ); + } + + bool operator!=( QueryPoolCreateInfoINTEL const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eQueryPoolCreateInfoINTEL; + + public: + const void* pNext = nullptr; + QueryPoolSamplingModeINTEL performanceCountersSampling; + }; + static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "struct and wrapper have different size!" ); + struct QueueFamilyCheckpointPropertiesNV { operator VkQueueFamilyCheckpointPropertiesNV const&() const @@ -45233,6 +46976,78 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" ); +#ifdef VK_USE_PLATFORM_GGP + struct StreamDescriptorSurfaceCreateInfoGGP + { + StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateFlagsGGP flags_ = StreamDescriptorSurfaceCreateFlagsGGP(), + GgpStreamDescriptor streamDescriptor_ = 0 ) + : flags( flags_ ) + , streamDescriptor( streamDescriptor_ ) + {} + + StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) + { + memcpy( this, &rhs, sizeof( StreamDescriptorSurfaceCreateInfoGGP ) ); + } + + StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) + { + memcpy( this, &rhs, sizeof( StreamDescriptorSurfaceCreateInfoGGP ) ); + return *this; + } + + StreamDescriptorSurfaceCreateInfoGGP & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + StreamDescriptorSurfaceCreateInfoGGP & setFlags( StreamDescriptorSurfaceCreateFlagsGGP flags_ ) + { + flags = flags_; + return *this; + } + + StreamDescriptorSurfaceCreateInfoGGP & setStreamDescriptor( GgpStreamDescriptor streamDescriptor_ ) + { + streamDescriptor = streamDescriptor_; + return *this; + } + + operator VkStreamDescriptorSurfaceCreateInfoGGP const&() const + { + return *reinterpret_cast( this ); + } + + operator VkStreamDescriptorSurfaceCreateInfoGGP &() + { + return *reinterpret_cast( this ); + } + + bool operator==( StreamDescriptorSurfaceCreateInfoGGP const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( streamDescriptor == rhs.streamDescriptor ); + } + + bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; + + public: + const void* pNext = nullptr; + StreamDescriptorSurfaceCreateFlagsGGP flags; + GgpStreamDescriptor streamDescriptor; + }; + static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_GGP*/ + struct SubmitInfo { SubmitInfo( uint32_t waitSemaphoreCount_ = 0, @@ -45674,6 +47489,68 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceCapabilitiesFullScreenExclusiveEXT + { + SurfaceCapabilitiesFullScreenExclusiveEXT( Bool32 fullScreenExclusiveSupported_ = 0 ) + : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ ) + {} + + SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) ); + } + + SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) ); + return *this; + } + + SurfaceCapabilitiesFullScreenExclusiveEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SurfaceCapabilitiesFullScreenExclusiveEXT & setFullScreenExclusiveSupported( Bool32 fullScreenExclusiveSupported_ ) + { + fullScreenExclusiveSupported = fullScreenExclusiveSupported_; + return *this; + } + + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported ); + } + + bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; + + public: + void* pNext = nullptr; + Bool32 fullScreenExclusiveSupported; + }; + static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct SurfaceFormatKHR { operator VkSurfaceFormatKHR const&() const @@ -45735,6 +47612,190 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceFullScreenExclusiveInfoEXT + { + SurfaceFullScreenExclusiveInfoEXT( FullScreenExclusiveEXT fullScreenExclusive_ = FullScreenExclusiveEXT::eDefault ) + : fullScreenExclusive( fullScreenExclusive_ ) + {} + + SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveInfoEXT ) ); + } + + SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveInfoEXT ) ); + return *this; + } + + SurfaceFullScreenExclusiveInfoEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SurfaceFullScreenExclusiveInfoEXT & setFullScreenExclusive( FullScreenExclusiveEXT fullScreenExclusive_ ) + { + fullScreenExclusive = fullScreenExclusive_; + return *this; + } + + operator VkSurfaceFullScreenExclusiveInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFullScreenExclusiveInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SurfaceFullScreenExclusiveInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fullScreenExclusive == rhs.fullScreenExclusive ); + } + + bool operator!=( SurfaceFullScreenExclusiveInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; + + public: + void* pNext = nullptr; + FullScreenExclusiveEXT fullScreenExclusive; + }; + static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceFullScreenExclusiveWin32InfoEXT + { + SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 ) + : hmonitor( hmonitor_ ) + {} + + SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) ); + } + + SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) ); + return *this; + } + + SurfaceFullScreenExclusiveWin32InfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SurfaceFullScreenExclusiveWin32InfoEXT & setHmonitor( HMONITOR hmonitor_ ) + { + hmonitor = hmonitor_; + return *this; + } + + operator VkSurfaceFullScreenExclusiveWin32InfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( hmonitor == rhs.hmonitor ); + } + + bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; + + public: + const void* pNext = nullptr; + HMONITOR hmonitor; + }; + static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct SurfaceProtectedCapabilitiesKHR + { + SurfaceProtectedCapabilitiesKHR( Bool32 supportsProtected_ = 0 ) + : supportsProtected( supportsProtected_ ) + {} + + SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceProtectedCapabilitiesKHR ) ); + } + + SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceProtectedCapabilitiesKHR ) ); + return *this; + } + + SurfaceProtectedCapabilitiesKHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SurfaceProtectedCapabilitiesKHR & setSupportsProtected( Bool32 supportsProtected_ ) + { + supportsProtected = supportsProtected_; + return *this; + } + + operator VkSurfaceProtectedCapabilitiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceProtectedCapabilitiesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SurfaceProtectedCapabilitiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( supportsProtected == rhs.supportsProtected ); + } + + bool operator!=( SurfaceProtectedCapabilitiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; + + public: + const void* pNext = nullptr; + Bool32 supportsProtected; + }; + static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "struct and wrapper have different size!" ); + struct SwapchainCounterCreateInfoEXT { SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() ) @@ -46005,6 +48066,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); + struct SwapchainDisplayNativeHdrCreateInfoAMD + { + SwapchainDisplayNativeHdrCreateInfoAMD( Bool32 localDimmingEnable_ = 0 ) + : localDimmingEnable( localDimmingEnable_ ) + {} + + SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) ); + } + + SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) ); + return *this; + } + + SwapchainDisplayNativeHdrCreateInfoAMD & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SwapchainDisplayNativeHdrCreateInfoAMD & setLocalDimmingEnable( Bool32 localDimmingEnable_ ) + { + localDimmingEnable = localDimmingEnable_; + return *this; + } + + operator VkSwapchainDisplayNativeHdrCreateInfoAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( localDimmingEnable == rhs.localDimmingEnable ); + } + + bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; + + public: + const void* pNext = nullptr; + Bool32 localDimmingEnable; + }; + static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "struct and wrapper have different size!" ); + struct TextureLODGatherFormatPropertiesAMD { operator VkTextureLODGatherFormatPropertiesAMD const&() const @@ -48416,6 +50537,48 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const + { + return static_cast( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast( pMarkerInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::setPerformanceMarkerINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d) const + { + return static_cast( d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast( pOverrideInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast( &overrideInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::setPerformanceOverrideINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const + { + return static_cast( d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast( pMarkerInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::setPerformanceStreamMarkerINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const { @@ -48634,6 +50797,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d) const + { + return static_cast( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d ) const + { + Result result = static_cast( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireFullScreenExclusiveModeEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const { @@ -48664,6 +50844,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d) const + { + return static_cast( d.vkAcquirePerformanceConfigurationINTEL( m_device, reinterpret_cast( pAcquireInfo ), reinterpret_cast( pConfiguration ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d ) const + { + PerformanceConfigurationINTEL configuration; + Result result = static_cast( d.vkAcquirePerformanceConfigurationINTEL( m_device, reinterpret_cast( &acquireInfo ), reinterpret_cast( &configuration ) ) ); + return createResultValue( result, configuration, VULKAN_HPP_NAMESPACE_STRING"::Device::acquirePerformanceConfigurationINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d) const { @@ -51033,6 +53228,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const + { + return static_cast( d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast( pSurfaceInfo ), reinterpret_cast( pModes ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const + { + DeviceGroupPresentModeFlagsKHR modes; + Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &modes ) ) ); + return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModes2EXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const { @@ -51521,6 +53733,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, PerformanceValueINTEL* pValue, Dispatch const &d) const + { + return static_cast( d.vkGetPerformanceParameterINTEL( m_device, static_cast( parameter ), reinterpret_cast( pValue ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const &d ) const + { + PerformanceValueINTEL value; + Result result = static_cast( d.vkGetPerformanceParameterINTEL( m_device, static_cast( parameter ), reinterpret_cast( &value ) ) ); + return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING"::Device::getPerformanceParameterINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const { @@ -51909,6 +54136,20 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template + VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d) const + { + return static_cast( d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast( pInitializeInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast( &initializeInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::initializePerformanceApiINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const { @@ -52018,6 +54259,38 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d) const + { + return static_cast( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d ) const + { + Result result = static_cast( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::releaseFullScreenExclusiveModeEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d) const + { + return static_cast( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d ) const + { + Result result = static_cast( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::releasePerformanceConfigurationINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d) const @@ -52077,6 +54350,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const + { + d.vkResetQueryPoolEXT( m_device, static_cast( queryPool ), firstQuery, queryCount ); + } +#else + template + VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const + { + d.vkResetQueryPoolEXT( m_device, static_cast( queryPool ), firstQuery, queryCount ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d) const { @@ -52141,6 +54428,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d) const + { + d.vkSetLocalDimmingAMD( m_device, static_cast( swapChain ), static_cast( localDimmingEnable ) ); + } +#else + template + VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d ) const + { + d.vkSetLocalDimmingAMD( m_device, static_cast( swapChain ), static_cast( localDimmingEnable ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const @@ -52169,6 +54470,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL(Dispatch const &d) const + { + d.vkUninitializePerformanceApiINTEL( m_device ); + } +#else + template + VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL(Dispatch const &d ) const + { + d.vkUninitializePerformanceApiINTEL( m_device ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::uninitializePerformanceApiINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d) const @@ -52364,6 +54680,32 @@ namespace VULKAN_HPP_NAMESPACE return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHRUnique", deleter ); } #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createHeadlessSurfaceEXT" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createHeadlessSurfaceEXTUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VK_USE_PLATFORM_IOS_MVK @@ -52478,6 +54820,34 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + template + VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createStreamDescriptorSurfaceGGP" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createStreamDescriptorSurfaceGGPUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_GGP*/ + #ifdef VK_USE_PLATFORM_VI_NN template VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const @@ -54272,6 +56642,58 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, pCombinationCount, reinterpret_cast( pCombinations ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(Dispatch const &d ) const + { + std::vector combinations; + uint32_t combinationCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && combinationCount ) + { + combinations.resize( combinationCount ); + result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, reinterpret_cast( combinations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); + combinations.resize( combinationCount ); + } + return createResultValue( result, combinations, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector combinations( vectorAllocator ); + uint32_t combinationCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && combinationCount ) + { + combinations.resize( combinationCount ); + result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, reinterpret_cast( combinations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); + combinations.resize( combinationCount ); + } + return createResultValue( result, combinations, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const { @@ -54429,6 +56851,60 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast( pSurfaceInfo ), pPresentModeCount, reinterpret_cast( pPresentModes ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const + { + std::vector presentModes; + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + presentModes.resize( presentModeCount ); + } + return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModes2EXT" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector presentModes( vectorAllocator ); + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + presentModes.resize( presentModeCount ); + } + return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModes2EXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const { @@ -54685,6 +57161,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d) const + { + return static_cast( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast( configuration ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d ) const + { + Result result = static_cast( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast( configuration ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::setPerformanceConfigurationINTEL" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d) const { @@ -54747,6 +57238,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -54809,8 +57301,8 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -54821,6 +57313,8 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -54844,6 +57338,8 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -54879,10 +57375,12 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -54890,8 +57388,10 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -54901,7 +57401,11 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -54916,6 +57420,9 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_GGP + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_GGP*/ template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -54932,7 +57439,20 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -55028,6 +57548,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetEvent vkCmdSetEvent = 0; PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; + PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; + PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; + PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; PFN_vkCmdSetScissor vkCmdSetScissor = 0; PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; @@ -55044,8 +57567,12 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; + PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; PFN_vkAllocateMemory vkAllocateMemory = 0; @@ -55139,6 +57666,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; @@ -55175,6 +57705,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; + PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; @@ -55197,6 +57728,7 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; PFN_vkMapMemory vkMapMemory = 0; PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; @@ -55204,16 +57736,23 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; PFN_vkResetCommandPool vkResetCommandPool = 0; PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; PFN_vkResetEvent vkResetEvent = 0; PFN_vkResetFences vkResetFences = 0; + PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; PFN_vkSetEvent vkSetEvent = 0; PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; + PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; PFN_vkTrimCommandPool vkTrimCommandPool = 0; PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; + PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; PFN_vkUnmapMemory vkUnmapMemory = 0; PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX = 0; PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; @@ -55226,6 +57765,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; + PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; #ifdef VK_USE_PLATFORM_IOS_MVK PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; #endif /*VK_USE_PLATFORM_IOS_MVK*/ @@ -55238,6 +57778,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_METAL_EXT PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; +#endif /*VK_USE_PLATFORM_GGP*/ #ifdef VK_USE_PLATFORM_VI_NN PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; #endif /*VK_USE_PLATFORM_VI_NN*/ @@ -55312,11 +57855,15 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; #ifdef VK_USE_PLATFORM_WAYLAND_KHR @@ -55341,6 +57888,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; + PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; PFN_vkQueueSubmit vkQueueSubmit = 0; PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; @@ -55454,6 +58002,9 @@ namespace VULKAN_HPP_NAMESPACE vkCmdSetEvent = PFN_vkCmdSetEvent( device ? vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) : vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) ); vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) ); vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( device ? vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) : vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) ); + vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) ); + vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) ); + vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) ); vkCmdSetScissor = PFN_vkCmdSetScissor( device ? vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) : vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) ); vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( device ? vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) : vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) ); @@ -55470,8 +58021,12 @@ namespace VULKAN_HPP_NAMESPACE vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( device ? vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) : vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) ); vkEndCommandBuffer = PFN_vkEndCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) ); vkResetCommandBuffer = PFN_vkResetCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( device ? vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) : vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( device ? vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) : vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) ); vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( device ? vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) : vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) ); + vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( device ? vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) : vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) ); vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( device ? vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) : vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) ); vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) ); vkAllocateMemory = PFN_vkAllocateMemory( device ? vkGetDeviceProcAddr( device, "vkAllocateMemory" ) : vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) ); @@ -55565,6 +58120,9 @@ namespace VULKAN_HPP_NAMESPACE vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) ); vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( device ? vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) ); vkGetDeviceQueue = PFN_vkGetDeviceQueue( device ? vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) ); @@ -55600,6 +58158,7 @@ namespace VULKAN_HPP_NAMESPACE vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) ); + vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( device ? vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) : vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) ); vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( device ? vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) ); vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( device ? vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) : vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) ); vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( device ? vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) : vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) ); @@ -55622,6 +58181,7 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( device ? vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) : vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) ); vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( device ? vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) : vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) ); vkMapMemory = PFN_vkMapMemory( device ? vkGetDeviceProcAddr( device, "vkMapMemory" ) : vkGetInstanceProcAddr( instance, "vkMapMemory" ) ); vkMergePipelineCaches = PFN_vkMergePipelineCaches( device ? vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) : vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) ); @@ -55629,16 +58189,23 @@ namespace VULKAN_HPP_NAMESPACE vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( device ? vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) : vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) ); vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( device ? vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) : vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) ); vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX( device ? vkGetDeviceProcAddr( device, "vkRegisterObjectsNVX" ) : vkGetInstanceProcAddr( instance, "vkRegisterObjectsNVX" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( device ? vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) : vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( device ? vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) : vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) ); vkResetCommandPool = PFN_vkResetCommandPool( device ? vkGetDeviceProcAddr( device, "vkResetCommandPool" ) : vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) ); vkResetDescriptorPool = PFN_vkResetDescriptorPool( device ? vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) : vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) ); vkResetEvent = PFN_vkResetEvent( device ? vkGetDeviceProcAddr( device, "vkResetEvent" ) : vkGetInstanceProcAddr( instance, "vkResetEvent" ) ); vkResetFences = PFN_vkResetFences( device ? vkGetDeviceProcAddr( device, "vkResetFences" ) : vkGetInstanceProcAddr( instance, "vkResetFences" ) ); + vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( device ? vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) : vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) ); vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( device ? vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) : vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) ); vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( device ? vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) : vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) ); vkSetEvent = PFN_vkSetEvent( device ? vkGetDeviceProcAddr( device, "vkSetEvent" ) : vkGetInstanceProcAddr( instance, "vkSetEvent" ) ); vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( device ? vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) : vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) ); + vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( device ? vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) : vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) ); vkTrimCommandPool = PFN_vkTrimCommandPool( device ? vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) : vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) ); vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( device ? vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) : vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) ); + vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( device ? vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) : vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) ); vkUnmapMemory = PFN_vkUnmapMemory( device ? vkGetDeviceProcAddr( device, "vkUnmapMemory" ) : vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) ); vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX( device ? vkGetDeviceProcAddr( device, "vkUnregisterObjectsNVX" ) : vkGetInstanceProcAddr( instance, "vkUnregisterObjectsNVX" ) ); vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( device ? vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) : vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) ); @@ -55651,6 +58218,7 @@ namespace VULKAN_HPP_NAMESPACE vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); + vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) ); #ifdef VK_USE_PLATFORM_IOS_MVK vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); #endif /*VK_USE_PLATFORM_IOS_MVK*/ @@ -55663,6 +58231,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_METAL_EXT vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); +#endif /*VK_USE_PLATFORM_GGP*/ #ifdef VK_USE_PLATFORM_VI_NN vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); #endif /*VK_USE_PLATFORM_VI_NN*/ @@ -55736,11 +58307,15 @@ namespace VULKAN_HPP_NAMESPACE vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); + vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) ); vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetPhysicalDeviceSurfacePresentModes2EXT = PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); #ifdef VK_USE_PLATFORM_WAYLAND_KHR @@ -55765,6 +58340,7 @@ namespace VULKAN_HPP_NAMESPACE vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) ); vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) ); vkQueuePresentKHR = PFN_vkQueuePresentKHR( device ? vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) : vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) ); + vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( device ? vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) : vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) ); vkQueueSubmit = PFN_vkQueueSubmit( device ? vkGetDeviceProcAddr( device, "vkQueueSubmit" ) : vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) ); vkQueueWaitIdle = PFN_vkQueueWaitIdle( device ? vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) : vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) ); }