diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index 66eb79b..7680392 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -13,10 +13,9 @@ module; #if !defined( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) # define VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING \ - "The Vulkan-Hpp C++ named module is experimental. " \ - "It is subject to change without prior notice.\n" \ - "To silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n\n" \ - "For feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues" + "\n\tThe Vulkan-Hpp C++ named module is experimental. It is subject to change without prior notice.\n" \ + "\tTo silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n" \ + "\tFor feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues" VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) #endif @@ -28,7 +27,8 @@ VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) #include #include -export module vulkan_hpp; +export module vulkan; +export import :video; export import std; export namespace VULKAN_HPP_NAMESPACE @@ -687,6 +687,14 @@ export namespace VULKAN_HPP_NAMESPACE //=== VK_AMD_memory_overallocation_behavior === using VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD; + //=== VK_EXT_present_timing === + using VULKAN_HPP_NAMESPACE::PastPresentationTimingFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PastPresentationTimingFlagsEXT; + using VULKAN_HPP_NAMESPACE::PresentStageFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PresentStageFlagsEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingInfoFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingInfoFlagsEXT; + //=== VK_INTEL_performance_query === using VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL; using VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL; @@ -1104,6 +1112,7 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::OutOfDeviceMemoryError; using VULKAN_HPP_NAMESPACE::OutOfHostMemoryError; using VULKAN_HPP_NAMESPACE::OutOfPoolMemoryError; + using VULKAN_HPP_NAMESPACE::PresentTimingQueueFullEXTError; using VULKAN_HPP_NAMESPACE::SurfaceLostKHRError; using VULKAN_HPP_NAMESPACE::SystemError; using VULKAN_HPP_NAMESPACE::TooManyObjectsError; @@ -1894,6 +1903,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::KHRTimelineSemaphoreExtensionName; using VULKAN_HPP_NAMESPACE::KHRTimelineSemaphoreSpecVersion; + //=== VK_EXT_present_timing === + using VULKAN_HPP_NAMESPACE::EXTPresentTimingExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPresentTimingSpecVersion; + //=== VK_INTEL_shader_integer_functions2 === using VULKAN_HPP_NAMESPACE::INTELShaderIntegerFunctions2ExtensionName; using VULKAN_HPP_NAMESPACE::INTELShaderIntegerFunctions2SpecVersion; @@ -4163,6 +4176,19 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV; using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV; + //=== VK_EXT_present_timing === + using VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT; + using VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT; + using VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PresentStageTimeEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT; + using VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT; + using VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT; + //=== VK_INTEL_shader_integer_functions2 === using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; @@ -7606,6 +7632,30 @@ export namespace std template <> struct hash; + //=== VK_EXT_present_timing === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + //=== VK_INTEL_shader_integer_functions2 === template <> struct hash; @@ -10090,6 +10140,12 @@ export using ::PFN_vkSignalSemaphoreKHR; using ::PFN_vkWaitSemaphoresKHR; + //=== VK_EXT_present_timing === + using ::PFN_vkGetPastPresentationTimingEXT; + using ::PFN_vkGetSwapchainTimeDomainPropertiesEXT; + using ::PFN_vkGetSwapchainTimingPropertiesEXT; + using ::PFN_vkSetSwapchainPresentTimingQueueSizeEXT; + //=== VK_INTEL_performance_query === using ::PFN_vkAcquirePerformanceConfigurationINTEL; using ::PFN_vkCmdSetPerformanceMarkerINTEL; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index dd95b5e..6c89bea 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -57,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # endif #endif -VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 334, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 335, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -4443,6 +4443,36 @@ namespace VULKAN_HPP_NAMESPACE return ::vkSignalSemaphoreKHR( device, pSignalInfo ); } + //=== VK_EXT_present_timing === + + VkResult vkSetSwapchainPresentTimingQueueSizeEXT( VkDevice device, VkSwapchainKHR swapchain, uint32_t size ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetSwapchainPresentTimingQueueSizeEXT( device, swapchain, size ); + } + + VkResult vkGetSwapchainTimingPropertiesEXT( VkDevice device, + VkSwapchainKHR swapchain, + VkSwapchainTimingPropertiesEXT * pSwapchainTimingProperties, + uint64_t * pSwapchainTimingPropertiesCounter ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSwapchainTimingPropertiesEXT( device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter ); + } + + VkResult vkGetSwapchainTimeDomainPropertiesEXT( VkDevice device, + VkSwapchainKHR swapchain, + VkSwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSwapchainTimeDomainPropertiesEXT( device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter ); + } + + VkResult vkGetPastPresentationTimingEXT( VkDevice device, + const VkPastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + VkPastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPastPresentationTimingEXT( device, pPastPresentationTimingInfo, pPastPresentationTimingProperties ); + } + //=== VK_INTEL_performance_query === VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT @@ -7240,6 +7270,14 @@ namespace VULKAN_HPP_NAMESPACE } }; + class PresentTimingQueueFullEXTError : public SystemError + { + public: + PresentTimingQueueFullEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorPresentTimingQueueFullEXT ), message ) {} + + PresentTimingQueueFullEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorPresentTimingQueueFullEXT ), message ) {} + }; + # if defined( VK_USE_PLATFORM_WIN32_KHR ) class FullScreenExclusiveModeLostEXTError : public SystemError { @@ -7313,6 +7351,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorVideoProfileCodecNotSupportedKHR : throw VideoProfileCodecNotSupportedKHRError( message ); case Result::eErrorVideoStdVersionNotSupportedKHR : throw VideoStdVersionNotSupportedKHRError( message ); case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message ); + case Result::eErrorPresentTimingQueueFullEXT : throw PresentTimingQueueFullEXTError( message ); # if defined( VK_USE_PLATFORM_WIN32_KHR ) case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message ); # endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -8469,6 +8508,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreExtensionName = VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreSpecVersion = VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION; + //=== VK_EXT_present_timing === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentTimingExtensionName = VK_EXT_PRESENT_TIMING_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentTimingSpecVersion = VK_EXT_PRESENT_TIMING_SPEC_VERSION; + //=== VK_INTEL_shader_integer_functions2 === VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2ExtensionName = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2SpecVersion = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION; @@ -13520,6 +13563,52 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_EXT_present_timing === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_INTEL_shader_integer_functions2 === template <> struct StructExtends @@ -20764,6 +20853,12 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; + //=== VK_EXT_present_timing === + PFN_vkSetSwapchainPresentTimingQueueSizeEXT vkSetSwapchainPresentTimingQueueSizeEXT = 0; + PFN_vkGetSwapchainTimingPropertiesEXT vkGetSwapchainTimingPropertiesEXT = 0; + PFN_vkGetSwapchainTimeDomainPropertiesEXT vkGetSwapchainTimeDomainPropertiesEXT = 0; + PFN_vkGetPastPresentationTimingEXT vkGetPastPresentationTimingEXT = 0; + //=== VK_INTEL_performance_query === PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; @@ -22251,6 +22346,14 @@ namespace VULKAN_HPP_NAMESPACE if ( !vkSignalSemaphore ) vkSignalSemaphore = vkSignalSemaphoreKHR; + //=== VK_EXT_present_timing === + vkSetSwapchainPresentTimingQueueSizeEXT = + PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetInstanceProcAddr( instance, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); + vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainTimingPropertiesEXT" ) ); + vkGetSwapchainTimeDomainPropertiesEXT = + PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); + vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingEXT" ) ); + //=== VK_INTEL_performance_query === vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) ); vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) ); @@ -23599,6 +23702,14 @@ namespace VULKAN_HPP_NAMESPACE if ( !vkSignalSemaphore ) vkSignalSemaphore = vkSignalSemaphoreKHR; + //=== VK_EXT_present_timing === + vkSetSwapchainPresentTimingQueueSizeEXT = + PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetDeviceProcAddr( device, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); + vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimingPropertiesEXT" ) ); + vkGetSwapchainTimeDomainPropertiesEXT = + PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); + vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingEXT" ) ); + //=== VK_INTEL_performance_query === vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index 4fc7e72..70f9e86 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -66,7 +66,7 @@ extern "C" { //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 334 +#define VK_HEADER_VERSION 335 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -177,6 +177,7 @@ typedef enum VkResult { VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT = -1000208000, VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, VK_THREAD_IDLE_KHR = 1000268000, VK_THREAD_DONE_KHR = 1000268001, @@ -746,6 +747,16 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT = 1000208000, + VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT = 1000208001, + VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT = 1000208002, + VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT = 1000208003, + VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT = 1000208004, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT = 1000208005, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT = 1000208006, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT = 1000208007, + VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT = 1000208008, + VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT = 1000208009, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, @@ -8881,6 +8892,7 @@ typedef enum VkSwapchainCreateFlagBitsKHR { VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, + VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT = 0x00000200, VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040, VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008, @@ -13376,6 +13388,8 @@ typedef enum VkTimeDomainKHR { VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR = 1, VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR = 2, VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR = 3, + VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT = 1000208000, + VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT = 1000208001, VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR, VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, @@ -16812,6 +16826,161 @@ VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( #endif +// VK_EXT_present_timing is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_present_timing 1 +#define VK_EXT_PRESENT_TIMING_SPEC_VERSION 3 +#define VK_EXT_PRESENT_TIMING_EXTENSION_NAME "VK_EXT_present_timing" +typedef VkFlags VkPresentStageFlagsEXT; + +typedef enum VkPresentStageFlagBitsEXT { + VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT = 0x00000001, + VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT = 0x00000002, + VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT = 0x00000004, + VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT = 0x00000008, + VK_PRESENT_STAGE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentStageFlagBitsEXT; +typedef VkFlags VkPastPresentationTimingFlagsEXT; + +typedef enum VkPastPresentationTimingFlagBitsEXT { + VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT = 0x00000001, + VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT = 0x00000002, + VK_PAST_PRESENTATION_TIMING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPastPresentationTimingFlagBitsEXT; +typedef VkFlags VkPresentTimingInfoFlagsEXT; + +typedef enum VkPresentTimingInfoFlagBitsEXT { + VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT = 0x00000001, + VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT = 0x00000002, + VK_PRESENT_TIMING_INFO_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentTimingInfoFlagBitsEXT; +typedef struct VkPhysicalDevicePresentTimingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 presentTiming; + VkBool32 presentAtAbsoluteTime; + VkBool32 presentAtRelativeTime; +} VkPhysicalDevicePresentTimingFeaturesEXT; + +typedef struct VkPresentTimingSurfaceCapabilitiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 presentTimingSupported; + VkBool32 presentAtAbsoluteTimeSupported; + VkBool32 presentAtRelativeTimeSupported; + VkPresentStageFlagsEXT presentStageQueries; +} VkPresentTimingSurfaceCapabilitiesEXT; + +typedef struct VkSwapchainCalibratedTimestampInfoEXT { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + VkPresentStageFlagsEXT presentStage; + uint64_t timeDomainId; +} VkSwapchainCalibratedTimestampInfoEXT; + +typedef struct VkSwapchainTimingPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t refreshDuration; + uint64_t refreshInterval; +} VkSwapchainTimingPropertiesEXT; + +typedef struct VkSwapchainTimeDomainPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t timeDomainCount; + VkTimeDomainKHR* pTimeDomains; + uint64_t* pTimeDomainIds; +} VkSwapchainTimeDomainPropertiesEXT; + +typedef struct VkPastPresentationTimingInfoEXT { + VkStructureType sType; + const void* pNext; + VkPastPresentationTimingFlagsEXT flags; + VkSwapchainKHR swapchain; +} VkPastPresentationTimingInfoEXT; + +typedef struct VkPresentStageTimeEXT { + VkPresentStageFlagsEXT stage; + uint64_t time; +} VkPresentStageTimeEXT; + +typedef struct VkPastPresentationTimingEXT { + VkStructureType sType; + void* pNext; + uint64_t presentId; + uint64_t targetTime; + uint32_t presentStageCount; + VkPresentStageTimeEXT* pPresentStages; + VkTimeDomainKHR timeDomain; + uint64_t timeDomainId; + VkBool32 reportComplete; +} VkPastPresentationTimingEXT; + +typedef struct VkPastPresentationTimingPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t timingPropertiesCounter; + uint64_t timeDomainsCounter; + uint32_t presentationTimingCount; + VkPastPresentationTimingEXT* pPresentationTimings; +} VkPastPresentationTimingPropertiesEXT; + +typedef struct VkPresentTimingInfoEXT { + VkStructureType sType; + const void* pNext; + VkPresentTimingInfoFlagsEXT flags; + uint64_t targetTime; + uint64_t timeDomainId; + VkPresentStageFlagsEXT presentStageQueries; + VkPresentStageFlagsEXT targetTimeDomainPresentStage; +} VkPresentTimingInfoEXT; + +typedef struct VkPresentTimingsInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimingInfoEXT* pTimingInfos; +} VkPresentTimingsInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkSetSwapchainPresentTimingQueueSizeEXT)(VkDevice device, VkSwapchainKHR swapchain, uint32_t size); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainTimingPropertiesEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainTimeDomainPropertiesEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingEXT)(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetSwapchainPresentTimingQueueSizeEXT( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t size); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimingPropertiesEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, + uint64_t* pSwapchainTimingPropertiesCounter); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimeDomainPropertiesEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, + uint64_t* pTimeDomainsCounter); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingEXT( + VkDevice device, + const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, + VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties); +#endif +#endif + + // VK_INTEL_shader_integer_functions2 is a preprocessor guard. Do not pass it to API calls. #define VK_INTEL_shader_integer_functions2 1 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index 2323ee7..acaeb28 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -282,6 +282,7 @@ namespace VULKAN_HPP_NAMESPACE eErrorVideoProfileCodecNotSupportedKHR = VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR, eErrorVideoStdVersionNotSupportedKHR = VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR, eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT, + eErrorPresentTimingQueueFullEXT = VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT, #if defined( VK_USE_PLATFORM_WIN32_KHR ) eErrorFullScreenExclusiveModeLostEXT = VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -1085,6 +1086,16 @@ namespace VULKAN_HPP_NAMESPACE eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, eQueueFamilyCheckpointProperties2NV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV, eCheckpointData2NV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV, + ePhysicalDevicePresentTimingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT, + eSwapchainTimingPropertiesEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT, + eSwapchainTimeDomainPropertiesEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT, + ePresentTimingsInfoEXT = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT, + ePresentTimingInfoEXT = VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT, + ePastPresentationTimingInfoEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT, + ePastPresentationTimingPropertiesEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT, + ePastPresentationTimingEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT, + ePresentTimingSurfaceCapabilitiesEXT = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT, + eSwapchainCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT, ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, eQueryPoolPerformanceQueryCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL, @@ -5543,6 +5554,7 @@ namespace VULKAN_HPP_NAMESPACE eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR, + ePresentTimingEXT = VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT, ePresentId2 = VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR, ePresentWait2 = VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR, eDeferredMemoryAllocation = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, @@ -5559,7 +5571,8 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SwapchainCreateFlagsKHR allFlags = SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions | SwapchainCreateFlagBitsKHR::eProtected | SwapchainCreateFlagBitsKHR::eMutableFormat | - SwapchainCreateFlagBitsKHR::ePresentId2 | SwapchainCreateFlagBitsKHR::ePresentWait2 | SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation; + SwapchainCreateFlagBitsKHR::ePresentTimingEXT | SwapchainCreateFlagBitsKHR::ePresentId2 | SwapchainCreateFlagBitsKHR::ePresentWait2 | + SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation; }; // wrapper class for enum VkDeviceGroupPresentModeFlagBitsKHR, see @@ -7182,6 +7195,70 @@ namespace VULKAN_HPP_NAMESPACE eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD }; + //=== VK_EXT_present_timing === + + // wrapper class for enum VkPresentStageFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageFlagBitsEXT.html + enum class PresentStageFlagBitsEXT : VkPresentStageFlagsEXT + { + eQueueOperationsEnd = VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT, + eRequestDequeued = VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT, + eImageFirstPixelOut = VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT, + eImageFirstPixelVisible = VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT + }; + + // wrapper using for bitmask VkPresentStageFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageFlagsEXT.html + using PresentStageFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPresentStageFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PresentStageFlagsEXT allFlags = + PresentStageFlagBitsEXT::eQueueOperationsEnd | PresentStageFlagBitsEXT::eRequestDequeued | PresentStageFlagBitsEXT::eImageFirstPixelOut | + PresentStageFlagBitsEXT::eImageFirstPixelVisible; + }; + + // wrapper class for enum VkPresentTimingInfoFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoFlagBitsEXT.html + enum class PresentTimingInfoFlagBitsEXT : VkPresentTimingInfoFlagsEXT + { + ePresentAtRelativeTime = VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT, + ePresentAtNearestRefreshCycle = VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT + }; + + // wrapper using for bitmask VkPresentTimingInfoFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoFlagsEXT.html + using PresentTimingInfoFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPresentTimingInfoFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PresentTimingInfoFlagsEXT allFlags = + PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime | PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle; + }; + + // wrapper class for enum VkPastPresentationTimingFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingFlagBitsEXT.html + enum class PastPresentationTimingFlagBitsEXT : VkPastPresentationTimingFlagsEXT + { + eAllowPartialResults = VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT, + eAllowOutOfOrderResults = VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT + }; + + // wrapper using for bitmask VkPastPresentationTimingFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingFlagsEXT.html + using PastPresentationTimingFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPastPresentationTimingFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PastPresentationTimingFlagsEXT allFlags = + PastPresentationTimingFlagBitsEXT::eAllowPartialResults | PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults; + }; + //=== VK_INTEL_performance_query === // wrapper class for enum VkPerformanceConfigurationTypeINTEL, see @@ -8976,7 +9053,9 @@ namespace VULKAN_HPP_NAMESPACE eDevice = VK_TIME_DOMAIN_DEVICE_KHR, eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, - eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR + eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR, + ePresentStageLocalEXT = VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT, + eSwapchainLocalEXT = VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT }; using TimeDomainEXT = TimeDomainKHR; diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index ffffe43..8b720a4 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -239,6 +239,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_NV_scissor_exclusive", "VK_NV_device_diagnostic_checkpoints", "VK_KHR_timeline_semaphore", + "VK_EXT_present_timing", "VK_INTEL_shader_integer_functions2", "VK_INTEL_performance_query", "VK_KHR_vulkan_memory_model", @@ -1367,6 +1368,14 @@ namespace VULKAN_HPP_NAMESPACE "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_present_timing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_calibrated_timestamps", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_present_id2", + "VK_KHR_swapchain", + } } } } }, { "VK_INTEL_shader_integer_functions2", { { "VK_VERSION_1_0", { { @@ -3835,7 +3844,7 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_mesh_shader" ) || ( extension == "VK_NV_fragment_shader_barycentric" ) || ( extension == "VK_NV_shader_image_footprint" ) || ( extension == "VK_NV_scissor_exclusive" ) || ( extension == "VK_NV_device_diagnostic_checkpoints" ) || - ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_INTEL_shader_integer_functions2" ) || + ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_EXT_present_timing" ) || ( extension == "VK_INTEL_shader_integer_functions2" ) || ( extension == "VK_INTEL_performance_query" ) || ( extension == "VK_KHR_vulkan_memory_model" ) || ( extension == "VK_EXT_pci_bus_info" ) || ( extension == "VK_AMD_display_native_hdr" ) || ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_fragment_density_map" ) || ( extension == "VK_EXT_scalar_block_layout" ) || diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index 566900b..4383b40 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -20269,6 +20269,108 @@ namespace VULKAN_HPP_NAMESPACE } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_EXT_present_timing === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + template ::value, bool>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, + uint32_t size, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkSetSwapchainPresentTimingQueueSizeEXT( static_cast( m_device ), static_cast( swapchain ), size ) ); + } +#else + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + template ::value, bool>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, uint32_t size, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetSwapchainPresentTimingQueueSizeEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkSetSwapchainPresentTimingQueueSizeEXT( m_device, static_cast( swapchain ), size ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setSwapchainPresentTimingQueueSizeEXT", { Result::eSuccess, Result::eNotReady } ); + + return static_cast( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + template ::value, bool>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, + SwapchainTimingPropertiesEXT * pSwapchainTimingProperties, + uint64_t * pSwapchainTimingPropertiesCounter, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSwapchainTimingPropertiesEXT( static_cast( m_device ), + static_cast( swapchain ), + reinterpret_cast( pSwapchainTimingProperties ), + pSwapchainTimingPropertiesCounter ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + template ::value, bool>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSwapchainTimingPropertiesEXT && "Function requires " ); +# endif + + std::pair data_; + SwapchainTimingPropertiesEXT & swapchainTimingProperties = data_.first; + uint64_t & swapchainTimingPropertiesCounter = data_.second; + Result result = static_cast( d.vkGetSwapchainTimingPropertiesEXT( m_device, + static_cast( swapchain ), + reinterpret_cast( &swapchainTimingProperties ), + &swapchainTimingPropertiesCounter ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainTimingPropertiesEXT", { Result::eSuccess, Result::eNotReady } ); + + return ResultValue>( result, std::move( data_ ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html + template ::value, bool>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainTimeDomainPropertiesEXT( SwapchainKHR swapchain, + SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetSwapchainTimeDomainPropertiesEXT( static_cast( m_device ), + static_cast( swapchain ), + reinterpret_cast( pSwapchainTimeDomainProperties ), + pTimeDomainsCounter ) ); + } + + // wrapper function for command vkGetPastPresentationTimingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html + template ::value, bool>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPastPresentationTimingEXT( static_cast( m_device ), + reinterpret_cast( pPastPresentationTimingInfo ), + reinterpret_cast( pPastPresentationTimingProperties ) ) ); + } + //=== VK_INTEL_performance_query === // wrapper function for command vkInitializePerformanceApiINTEL, see diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index 12f04c7..808496c 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -1118,6 +1118,19 @@ namespace VULKAN_HPP_NAMESPACE struct QueueFamilyCheckpointProperties2NV; struct CheckpointData2NV; + //=== VK_EXT_present_timing === + struct PhysicalDevicePresentTimingFeaturesEXT; + struct PresentTimingSurfaceCapabilitiesEXT; + struct SwapchainCalibratedTimestampInfoEXT; + struct SwapchainTimingPropertiesEXT; + struct SwapchainTimeDomainPropertiesEXT; + struct PastPresentationTimingInfoEXT; + struct PastPresentationTimingPropertiesEXT; + struct PastPresentationTimingEXT; + struct PresentTimingsInfoEXT; + struct PresentTimingInfoEXT; + struct PresentStageTimeEXT; + //=== VK_INTEL_shader_integer_functions2 === struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; @@ -15645,6 +15658,54 @@ namespace VULKAN_HPP_NAMESPACE signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_EXT_present_timing === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + template ::value, bool>::type = true> + VULKAN_HPP_NODISCARD Result setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, + uint32_t size, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + template ::value, bool>::type = true> + VULKAN_HPP_NODISCARD Result setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, + uint32_t size, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + template ::value, bool>::type = true> + VULKAN_HPP_NODISCARD Result getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, + SwapchainTimingPropertiesEXT * pSwapchainTimingProperties, + uint64_t * pSwapchainTimingPropertiesCounter, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + template ::value, bool>::type = true> + VULKAN_HPP_NODISCARD ResultValue> + getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html + template ::value, bool>::type = true> + VULKAN_HPP_NODISCARD Result getSwapchainTimeDomainPropertiesEXT( SwapchainKHR swapchain, + SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPastPresentationTimingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html + template ::value, bool>::type = true> + VULKAN_HPP_NODISCARD Result getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + //=== VK_INTEL_performance_query === // wrapper function for command vkInitializePerformanceApiINTEL, see diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index 14b96a2..a67ae47 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -8803,6 +8803,37 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentStageTimeEXT const & presentStageTimeEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentStageTimeEXT.stage ); + VULKAN_HPP_HASH_COMBINE( seed, presentStageTimeEXT.time ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT const & pastPresentationTimingEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.presentId ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.targetTime ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.presentStageCount ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.pPresentStages ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.timeDomain ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.timeDomainId ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.reportComplete ); + return seed; + } + }; + template <> struct hash { @@ -8818,6 +8849,36 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT const & pastPresentationTimingInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.swapchain ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT const & pastPresentationTimingPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.timingPropertiesCounter ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.timeDomainsCounter ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.presentationTimingCount ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.pPresentationTimings ); + return seed; + } + }; + template <> struct hash { @@ -12885,6 +12946,22 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT const & physicalDevicePresentTimingFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentTiming ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentAtAbsoluteTime ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentAtRelativeTime ); + return seed; + } + }; + template <> struct hash { @@ -16398,6 +16475,53 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT const & presentTimingInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.targetTime ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.timeDomainId ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.presentStageQueries ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.targetTimeDomainPresentStage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT const & presentTimingSurfaceCapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentTimingSupported ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentAtAbsoluteTimeSupported ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentAtRelativeTimeSupported ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentStageQueries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT const & presentTimingsInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.pTimingInfos ); + return seed; + } + }; + template <> struct hash { @@ -18377,6 +18501,21 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT const & swapchainCalibratedTimestampInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.swapchain ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.presentStage ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.timeDomainId ); + return seed; + } + }; + template <> struct hash { @@ -18530,6 +18669,35 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT const & swapchainTimeDomainPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.timeDomainCount ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pTimeDomains ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pTimeDomainIds ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT const & swapchainTimingPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.refreshDuration ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.refreshInterval ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index bbaba52..355f766 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -1312,6 +1312,14 @@ namespace VULKAN_HPP_NAMESPACE if ( !vkSignalSemaphore ) vkSignalSemaphore = vkSignalSemaphoreKHR; + //=== VK_EXT_present_timing === + vkSetSwapchainPresentTimingQueueSizeEXT = + PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetDeviceProcAddr( device, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); + vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimingPropertiesEXT" ) ); + vkGetSwapchainTimeDomainPropertiesEXT = + PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); + vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingEXT" ) ); + //=== VK_INTEL_performance_query === vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); @@ -2483,6 +2491,12 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; + //=== VK_EXT_present_timing === + PFN_vkSetSwapchainPresentTimingQueueSizeEXT vkSetSwapchainPresentTimingQueueSizeEXT = 0; + PFN_vkGetSwapchainTimingPropertiesEXT vkGetSwapchainTimingPropertiesEXT = 0; + PFN_vkGetSwapchainTimeDomainPropertiesEXT vkGetSwapchainTimeDomainPropertiesEXT = 0; + PFN_vkGetPastPresentationTimingEXT vkGetPastPresentationTimingEXT = 0; + //=== VK_INTEL_performance_query === PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; @@ -5069,6 +5083,14 @@ namespace VULKAN_HPP_NAMESPACE // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html typename ResultValueType::type signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const; + //=== VK_EXT_present_timing === + + // wrapper function for command vkGetPastPresentationTimingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html + VULKAN_HPP_NODISCARD Result + getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT; + //=== VK_INTEL_performance_query === // wrapper function for command vkInitializePerformanceApiINTEL, see @@ -14256,6 +14278,21 @@ namespace VULKAN_HPP_NAMESPACE // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html VULKAN_HPP_NODISCARD Result getStatus() const; + //=== VK_EXT_present_timing === + + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + VULKAN_HPP_NODISCARD Result setPresentTimingQueueSizeEXT( uint32_t size ) const; + + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + VULKAN_HPP_NODISCARD ResultValue> getTimingPropertiesEXT() const; + + // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html + VULKAN_HPP_NODISCARD Result getTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT; + //=== VK_AMD_display_native_hdr === // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html @@ -23016,6 +23053,70 @@ namespace VULKAN_HPP_NAMESPACE return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); } + //=== VK_EXT_present_timing === + + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::setPresentTimingQueueSizeEXT( uint32_t size ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetSwapchainPresentTimingQueueSizeEXT && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkSetSwapchainPresentTimingQueueSizeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ), size ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::setPresentTimingQueueSizeEXT", { Result::eSuccess, Result::eNotReady } ); + + return static_cast( result ); + } + + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> SwapchainKHR::getTimingPropertiesEXT() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainTimingPropertiesEXT && + "Function requires " ); + + std::pair data_; + SwapchainTimingPropertiesEXT & swapchainTimingProperties = data_.first; + uint64_t & swapchainTimingPropertiesCounter = data_.second; + Result result = static_cast( + getDispatcher()->vkGetSwapchainTimingPropertiesEXT( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( &swapchainTimingProperties ), + &swapchainTimingPropertiesCounter ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getTimingPropertiesEXT", { Result::eSuccess, Result::eNotReady } ); + + return ResultValue>( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::getTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainTimeDomainPropertiesEXT && + "Function requires " ); + return static_cast( + getDispatcher()->vkGetSwapchainTimeDomainPropertiesEXT( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( pSwapchainTimeDomainProperties ), + pTimeDomainsCounter ) ); + } // wrapper function for command vkGetPastPresentationTimingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPastPresentationTimingEXT && "Function requires " ); + return static_cast( + getDispatcher()->vkGetPastPresentationTimingEXT( static_cast( m_device ), + reinterpret_cast( pPastPresentationTimingInfo ), + reinterpret_cast( pPastPresentationTimingProperties ) ) ); + } + //=== VK_INTEL_performance_query === // wrapper function for command vkInitializePerformanceApiINTEL, see diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index f63e058..67c86a0 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -4403,6 +4403,76 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "CheckpointData2NV is not nothrow_move_constructible!" ); +//=== VK_EXT_present_timing === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT ) == sizeof( VkPhysicalDevicePresentTimingFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentTimingFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT ) == sizeof( VkPresentTimingSurfaceCapabilitiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentTimingSurfaceCapabilitiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT ) == sizeof( VkSwapchainCalibratedTimestampInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainCalibratedTimestampInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT ) == sizeof( VkSwapchainTimingPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainTimingPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT ) == sizeof( VkSwapchainTimeDomainPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainTimeDomainPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT ) == sizeof( VkPastPresentationTimingInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PastPresentationTimingInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT ) == sizeof( VkPastPresentationTimingPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PastPresentationTimingPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT ) == sizeof( VkPastPresentationTimingEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PastPresentationTimingEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT ) == sizeof( VkPresentTimingsInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentTimingsInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT ) == sizeof( VkPresentTimingInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentTimingInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentStageTimeEXT ) == sizeof( VkPresentStageTimeEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentStageTimeEXT is not nothrow_move_constructible!" ); + //=== VK_INTEL_shader_integer_functions2 === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index 462a240..8a84998 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -75594,6 +75594,310 @@ namespace VULKAN_HPP_NAMESPACE }; #endif + // wrapper struct for struct VkPresentStageTimeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageTimeEXT.html + struct PresentStageTimeEXT + { + using NativeType = VkPresentStageTimeEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentStageTimeEXT( PresentStageFlagsEXT stage_ = {}, uint64_t time_ = {} ) VULKAN_HPP_NOEXCEPT + : stage{ stage_ } + , time{ time_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentStageTimeEXT( PresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentStageTimeEXT( VkPresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT : PresentStageTimeEXT( *reinterpret_cast( &rhs ) ) + { + } + + PresentStageTimeEXT & operator=( PresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentStageTimeEXT & operator=( VkPresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentStageTimeEXT & setStage( PresentStageFlagsEXT stage_ ) VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentStageTimeEXT & setTime( uint64_t time_ ) VULKAN_HPP_NOEXCEPT + { + time = time_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentStageTimeEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentStageTimeEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentStageTimeEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentStageTimeEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( stage, time ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentStageTimeEXT const & ) const = default; +#else + bool operator==( PresentStageTimeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( stage == rhs.stage ) && ( time == rhs.time ); +# endif + } + + bool operator!=( PresentStageTimeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + PresentStageFlagsEXT stage = {}; + uint64_t time = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentStageTimeEXT; + }; +#endif + + // wrapper struct for struct VkPastPresentationTimingEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingEXT.html + struct PastPresentationTimingEXT + { + using NativeType = VkPastPresentationTimingEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PastPresentationTimingEXT( uint64_t presentId_ = {}, + uint64_t targetTime_ = {}, + uint32_t presentStageCount_ = {}, + PresentStageTimeEXT * pPresentStages_ = {}, + TimeDomainKHR timeDomain_ = TimeDomainKHR::eDevice, + uint64_t timeDomainId_ = {}, + Bool32 reportComplete_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentId{ presentId_ } + , targetTime{ targetTime_ } + , presentStageCount{ presentStageCount_ } + , pPresentStages{ pPresentStages_ } + , timeDomain{ timeDomain_ } + , timeDomainId{ timeDomainId_ } + , reportComplete{ reportComplete_ } + { + } + + VULKAN_HPP_CONSTEXPR PastPresentationTimingEXT( PastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PastPresentationTimingEXT( VkPastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PastPresentationTimingEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PastPresentationTimingEXT( uint64_t presentId_, + uint64_t targetTime_, + ArrayProxyNoTemporaries const & presentStages_, + TimeDomainKHR timeDomain_ = TimeDomainKHR::eDevice, + uint64_t timeDomainId_ = {}, + Bool32 reportComplete_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , presentId( presentId_ ) + , targetTime( targetTime_ ) + , presentStageCount( static_cast( presentStages_.size() ) ) + , pPresentStages( presentStages_.data() ) + , timeDomain( timeDomain_ ) + , timeDomainId( timeDomainId_ ) + , reportComplete( reportComplete_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PastPresentationTimingEXT & operator=( PastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PastPresentationTimingEXT & operator=( VkPastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingEXT & setPresentId( uint64_t presentId_ ) VULKAN_HPP_NOEXCEPT + { + presentId = presentId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingEXT & setTargetTime( uint64_t targetTime_ ) VULKAN_HPP_NOEXCEPT + { + targetTime = targetTime_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingEXT & setPresentStageCount( uint32_t presentStageCount_ ) VULKAN_HPP_NOEXCEPT + { + presentStageCount = presentStageCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingEXT & setPPresentStages( PresentStageTimeEXT * pPresentStages_ ) VULKAN_HPP_NOEXCEPT + { + pPresentStages = pPresentStages_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PastPresentationTimingEXT & setPresentStages( ArrayProxyNoTemporaries const & presentStages_ ) VULKAN_HPP_NOEXCEPT + { + presentStageCount = static_cast( presentStages_.size() ); + pPresentStages = presentStages_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingEXT & setTimeDomain( TimeDomainKHR timeDomain_ ) VULKAN_HPP_NOEXCEPT + { + timeDomain = timeDomain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingEXT & setTimeDomainId( uint64_t timeDomainId_ ) VULKAN_HPP_NOEXCEPT + { + timeDomainId = timeDomainId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingEXT & setReportComplete( Bool32 reportComplete_ ) VULKAN_HPP_NOEXCEPT + { + reportComplete = reportComplete_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPastPresentationTimingEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPastPresentationTimingEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentId, targetTime, presentStageCount, pPresentStages, timeDomain, timeDomainId, reportComplete ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PastPresentationTimingEXT const & ) const = default; +#else + bool operator==( PastPresentationTimingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ) && ( targetTime == rhs.targetTime ) && + ( presentStageCount == rhs.presentStageCount ) && ( pPresentStages == rhs.pPresentStages ) && ( timeDomain == rhs.timeDomain ) && + ( timeDomainId == rhs.timeDomainId ) && ( reportComplete == rhs.reportComplete ); +# endif + } + + bool operator!=( PastPresentationTimingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePastPresentationTimingEXT; + void * pNext = {}; + uint64_t presentId = {}; + uint64_t targetTime = {}; + uint32_t presentStageCount = {}; + PresentStageTimeEXT * pPresentStages = {}; + TimeDomainKHR timeDomain = TimeDomainKHR::eDevice; + uint64_t timeDomainId = {}; + Bool32 reportComplete = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PastPresentationTimingEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PastPresentationTimingEXT; + }; + // wrapper struct for struct VkPastPresentationTimingGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingGOOGLE.html struct PastPresentationTimingGOOGLE { @@ -75691,6 +75995,294 @@ namespace VULKAN_HPP_NAMESPACE }; #endif + // wrapper struct for struct VkPastPresentationTimingInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingInfoEXT.html + struct PastPresentationTimingInfoEXT + { + using NativeType = VkPastPresentationTimingInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PastPresentationTimingInfoEXT( PastPresentationTimingFlagsEXT flags_ = {}, + SwapchainKHR swapchain_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , swapchain{ swapchain_ } + { + } + + VULKAN_HPP_CONSTEXPR PastPresentationTimingInfoEXT( PastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PastPresentationTimingInfoEXT( VkPastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PastPresentationTimingInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PastPresentationTimingInfoEXT & operator=( PastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PastPresentationTimingInfoEXT & operator=( VkPastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setFlags( PastPresentationTimingFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setSwapchain( SwapchainKHR swapchain_ ) VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPastPresentationTimingInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPastPresentationTimingInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, swapchain ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PastPresentationTimingInfoEXT const & ) const = default; +#else + bool operator==( PastPresentationTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( swapchain == rhs.swapchain ); +# endif + } + + bool operator!=( PastPresentationTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePastPresentationTimingInfoEXT; + const void * pNext = {}; + PastPresentationTimingFlagsEXT flags = {}; + SwapchainKHR swapchain = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PastPresentationTimingInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PastPresentationTimingInfoEXT; + }; + + // wrapper struct for struct VkPastPresentationTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingPropertiesEXT.html + struct PastPresentationTimingPropertiesEXT + { + using NativeType = VkPastPresentationTimingPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PastPresentationTimingPropertiesEXT( uint64_t timingPropertiesCounter_ = {}, + uint64_t timeDomainsCounter_ = {}, + uint32_t presentationTimingCount_ = {}, + PastPresentationTimingEXT * pPresentationTimings_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , timingPropertiesCounter{ timingPropertiesCounter_ } + , timeDomainsCounter{ timeDomainsCounter_ } + , presentationTimingCount{ presentationTimingCount_ } + , pPresentationTimings{ pPresentationTimings_ } + { + } + + VULKAN_HPP_CONSTEXPR PastPresentationTimingPropertiesEXT( PastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PastPresentationTimingPropertiesEXT( VkPastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PastPresentationTimingPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PastPresentationTimingPropertiesEXT( uint64_t timingPropertiesCounter_, + uint64_t timeDomainsCounter_, + ArrayProxyNoTemporaries const & presentationTimings_, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , timingPropertiesCounter( timingPropertiesCounter_ ) + , timeDomainsCounter( timeDomainsCounter_ ) + , presentationTimingCount( static_cast( presentationTimings_.size() ) ) + , pPresentationTimings( presentationTimings_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PastPresentationTimingPropertiesEXT & operator=( PastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PastPresentationTimingPropertiesEXT & operator=( VkPastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingPropertiesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingPropertiesEXT & setTimingPropertiesCounter( uint64_t timingPropertiesCounter_ ) VULKAN_HPP_NOEXCEPT + { + timingPropertiesCounter = timingPropertiesCounter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingPropertiesEXT & setTimeDomainsCounter( uint64_t timeDomainsCounter_ ) VULKAN_HPP_NOEXCEPT + { + timeDomainsCounter = timeDomainsCounter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingPropertiesEXT & setPresentationTimingCount( uint32_t presentationTimingCount_ ) VULKAN_HPP_NOEXCEPT + { + presentationTimingCount = presentationTimingCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingPropertiesEXT & + setPPresentationTimings( PastPresentationTimingEXT * pPresentationTimings_ ) VULKAN_HPP_NOEXCEPT + { + pPresentationTimings = pPresentationTimings_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PastPresentationTimingPropertiesEXT & + setPresentationTimings( ArrayProxyNoTemporaries const & presentationTimings_ ) VULKAN_HPP_NOEXCEPT + { + presentationTimingCount = static_cast( presentationTimings_.size() ); + pPresentationTimings = presentationTimings_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPastPresentationTimingPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPastPresentationTimingPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timingPropertiesCounter, timeDomainsCounter, presentationTimingCount, pPresentationTimings ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PastPresentationTimingPropertiesEXT const & ) const = default; +#else + bool operator==( PastPresentationTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timingPropertiesCounter == rhs.timingPropertiesCounter ) && + ( timeDomainsCounter == rhs.timeDomainsCounter ) && ( presentationTimingCount == rhs.presentationTimingCount ) && + ( pPresentationTimings == rhs.pPresentationTimings ); +# endif + } + + bool operator!=( PastPresentationTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePastPresentationTimingPropertiesEXT; + void * pNext = {}; + uint64_t timingPropertiesCounter = {}; + uint64_t timeDomainsCounter = {}; + uint32_t presentationTimingCount = {}; + PastPresentationTimingEXT * pPresentationTimings = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PastPresentationTimingPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PastPresentationTimingPropertiesEXT; + }; + // wrapper struct for struct VkPerTileBeginInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerTileBeginInfoQCOM.html struct PerTileBeginInfoQCOM { @@ -106659,6 +107251,137 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + // wrapper struct for struct VkPhysicalDevicePresentTimingFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentTimingFeaturesEXT.html + struct PhysicalDevicePresentTimingFeaturesEXT + { + using NativeType = VkPhysicalDevicePresentTimingFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentTimingFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentTimingFeaturesEXT( Bool32 presentTiming_ = {}, + Bool32 presentAtAbsoluteTime_ = {}, + Bool32 presentAtRelativeTime_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentTiming{ presentTiming_ } + , presentAtAbsoluteTime{ presentAtAbsoluteTime_ } + , presentAtRelativeTime{ presentAtRelativeTime_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentTimingFeaturesEXT( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentTimingFeaturesEXT( VkPhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentTimingFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentTimingFeaturesEXT & operator=( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentTimingFeaturesEXT & operator=( VkPhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentTiming( Bool32 presentTiming_ ) VULKAN_HPP_NOEXCEPT + { + presentTiming = presentTiming_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentAtAbsoluteTime( Bool32 presentAtAbsoluteTime_ ) VULKAN_HPP_NOEXCEPT + { + presentAtAbsoluteTime = presentAtAbsoluteTime_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentAtRelativeTime( Bool32 presentAtRelativeTime_ ) VULKAN_HPP_NOEXCEPT + { + presentAtRelativeTime = presentAtRelativeTime_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentTimingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentTimingFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentTimingFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentTimingFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentTiming, presentAtAbsoluteTime, presentAtRelativeTime ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentTimingFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentTiming == rhs.presentTiming ) && + ( presentAtAbsoluteTime == rhs.presentAtAbsoluteTime ) && ( presentAtRelativeTime == rhs.presentAtRelativeTime ); +# endif + } + + bool operator!=( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentTimingFeaturesEXT; + void * pNext = {}; + Bool32 presentTiming = {}; + Bool32 presentAtAbsoluteTime = {}; + Bool32 presentAtRelativeTime = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentTimingFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentTimingFeaturesEXT; + }; + // wrapper struct for struct VkPhysicalDevicePresentWait2FeaturesKHR, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentWait2FeaturesKHR.html struct PhysicalDevicePresentWait2FeaturesKHR @@ -135176,6 +135899,441 @@ namespace VULKAN_HPP_NAMESPACE using Type = PresentTimesInfoGOOGLE; }; + // wrapper struct for struct VkPresentTimingInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoEXT.html + struct PresentTimingInfoEXT + { + using NativeType = VkPresentTimingInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentTimingInfoEXT( PresentTimingInfoFlagsEXT flags_ = {}, + uint64_t targetTime_ = {}, + uint64_t timeDomainId_ = {}, + PresentStageFlagsEXT presentStageQueries_ = {}, + PresentStageFlagsEXT targetTimeDomainPresentStage_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , targetTime{ targetTime_ } + , timeDomainId{ timeDomainId_ } + , presentStageQueries{ presentStageQueries_ } + , targetTimeDomainPresentStage{ targetTimeDomainPresentStage_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentTimingInfoEXT( PresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentTimingInfoEXT( VkPresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PresentTimingInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PresentTimingInfoEXT & operator=( PresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentTimingInfoEXT & operator=( VkPresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setFlags( PresentTimingInfoFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTargetTime( uint64_t targetTime_ ) VULKAN_HPP_NOEXCEPT + { + targetTime = targetTime_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTimeDomainId( uint64_t timeDomainId_ ) VULKAN_HPP_NOEXCEPT + { + timeDomainId = timeDomainId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setPresentStageQueries( PresentStageFlagsEXT presentStageQueries_ ) VULKAN_HPP_NOEXCEPT + { + presentStageQueries = presentStageQueries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTargetTimeDomainPresentStage( PresentStageFlagsEXT targetTimeDomainPresentStage_ ) VULKAN_HPP_NOEXCEPT + { + targetTimeDomainPresentStage = targetTimeDomainPresentStage_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentTimingInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentTimingInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, targetTime, timeDomainId, presentStageQueries, targetTimeDomainPresentStage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentTimingInfoEXT const & ) const = default; +#else + bool operator==( PresentTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( targetTime == rhs.targetTime ) && + ( timeDomainId == rhs.timeDomainId ) && ( presentStageQueries == rhs.presentStageQueries ) && + ( targetTimeDomainPresentStage == rhs.targetTimeDomainPresentStage ); +# endif + } + + bool operator!=( PresentTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentTimingInfoEXT; + const void * pNext = {}; + PresentTimingInfoFlagsEXT flags = {}; + uint64_t targetTime = {}; + uint64_t timeDomainId = {}; + PresentStageFlagsEXT presentStageQueries = {}; + PresentStageFlagsEXT targetTimeDomainPresentStage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentTimingInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PresentTimingInfoEXT; + }; + + // wrapper struct for struct VkPresentTimingSurfaceCapabilitiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingSurfaceCapabilitiesEXT.html + struct PresentTimingSurfaceCapabilitiesEXT + { + using NativeType = VkPresentTimingSurfaceCapabilitiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingSurfaceCapabilitiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentTimingSurfaceCapabilitiesEXT( Bool32 presentTimingSupported_ = {}, + Bool32 presentAtAbsoluteTimeSupported_ = {}, + Bool32 presentAtRelativeTimeSupported_ = {}, + PresentStageFlagsEXT presentStageQueries_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentTimingSupported{ presentTimingSupported_ } + , presentAtAbsoluteTimeSupported{ presentAtAbsoluteTimeSupported_ } + , presentAtRelativeTimeSupported{ presentAtRelativeTimeSupported_ } + , presentStageQueries{ presentStageQueries_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentTimingSurfaceCapabilitiesEXT( PresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentTimingSurfaceCapabilitiesEXT( VkPresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PresentTimingSurfaceCapabilitiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PresentTimingSurfaceCapabilitiesEXT & operator=( PresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentTimingSurfaceCapabilitiesEXT & operator=( VkPresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentTimingSurfaceCapabilitiesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingSurfaceCapabilitiesEXT & setPresentTimingSupported( Bool32 presentTimingSupported_ ) VULKAN_HPP_NOEXCEPT + { + presentTimingSupported = presentTimingSupported_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingSurfaceCapabilitiesEXT & + setPresentAtAbsoluteTimeSupported( Bool32 presentAtAbsoluteTimeSupported_ ) VULKAN_HPP_NOEXCEPT + { + presentAtAbsoluteTimeSupported = presentAtAbsoluteTimeSupported_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingSurfaceCapabilitiesEXT & + setPresentAtRelativeTimeSupported( Bool32 presentAtRelativeTimeSupported_ ) VULKAN_HPP_NOEXCEPT + { + presentAtRelativeTimeSupported = presentAtRelativeTimeSupported_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingSurfaceCapabilitiesEXT & setPresentStageQueries( PresentStageFlagsEXT presentStageQueries_ ) VULKAN_HPP_NOEXCEPT + { + presentStageQueries = presentStageQueries_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentTimingSurfaceCapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingSurfaceCapabilitiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingSurfaceCapabilitiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentTimingSurfaceCapabilitiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentTimingSupported, presentAtAbsoluteTimeSupported, presentAtRelativeTimeSupported, presentStageQueries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentTimingSurfaceCapabilitiesEXT const & ) const = default; +#else + bool operator==( PresentTimingSurfaceCapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentTimingSupported == rhs.presentTimingSupported ) && + ( presentAtAbsoluteTimeSupported == rhs.presentAtAbsoluteTimeSupported ) && + ( presentAtRelativeTimeSupported == rhs.presentAtRelativeTimeSupported ) && ( presentStageQueries == rhs.presentStageQueries ); +# endif + } + + bool operator!=( PresentTimingSurfaceCapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentTimingSurfaceCapabilitiesEXT; + void * pNext = {}; + Bool32 presentTimingSupported = {}; + Bool32 presentAtAbsoluteTimeSupported = {}; + Bool32 presentAtRelativeTimeSupported = {}; + PresentStageFlagsEXT presentStageQueries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentTimingSurfaceCapabilitiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PresentTimingSurfaceCapabilitiesEXT; + }; + + // wrapper struct for struct VkPresentTimingsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingsInfoEXT.html + struct PresentTimingsInfoEXT + { + using NativeType = VkPresentTimingsInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingsInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PresentTimingsInfoEXT( uint32_t swapchainCount_ = {}, const PresentTimingInfoEXT * pTimingInfos_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pTimingInfos{ pTimingInfos_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentTimingsInfoEXT( PresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentTimingsInfoEXT( VkPresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PresentTimingsInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentTimingsInfoEXT( ArrayProxyNoTemporaries const & timingInfos_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( timingInfos_.size() ) ), pTimingInfos( timingInfos_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PresentTimingsInfoEXT & operator=( PresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentTimingsInfoEXT & operator=( VkPresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setSwapchainCount( uint32_t swapchainCount_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setPTimingInfos( const PresentTimingInfoEXT * pTimingInfos_ ) VULKAN_HPP_NOEXCEPT + { + pTimingInfos = pTimingInfos_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentTimingsInfoEXT & setTimingInfos( ArrayProxyNoTemporaries const & timingInfos_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( timingInfos_.size() ); + pTimingInfos = timingInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentTimingsInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingsInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingsInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentTimingsInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pTimingInfos ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentTimingsInfoEXT const & ) const = default; +#else + bool operator==( PresentTimingsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pTimingInfos == rhs.pTimingInfos ); +# endif + } + + bool operator!=( PresentTimingsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentTimingsInfoEXT; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const PresentTimingInfoEXT * pTimingInfos = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentTimingsInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PresentTimingsInfoEXT; + }; + // wrapper struct for struct VkPresentWait2InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentWait2InfoKHR.html struct PresentWait2InfoKHR { @@ -152962,6 +154120,138 @@ namespace VULKAN_HPP_NAMESPACE using Type = SurfaceProtectedCapabilitiesKHR; }; + // wrapper struct for struct VkSwapchainCalibratedTimestampInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCalibratedTimestampInfoEXT.html + struct SwapchainCalibratedTimestampInfoEXT + { + using NativeType = VkSwapchainCalibratedTimestampInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCalibratedTimestampInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainCalibratedTimestampInfoEXT( SwapchainKHR swapchain_ = {}, + PresentStageFlagsEXT presentStage_ = {}, + uint64_t timeDomainId_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchain{ swapchain_ } + , presentStage{ presentStage_ } + , timeDomainId{ timeDomainId_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainCalibratedTimestampInfoEXT( SwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainCalibratedTimestampInfoEXT( VkSwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainCalibratedTimestampInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainCalibratedTimestampInfoEXT & operator=( SwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainCalibratedTimestampInfoEXT & operator=( VkSwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setSwapchain( SwapchainKHR swapchain_ ) VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setPresentStage( PresentStageFlagsEXT presentStage_ ) VULKAN_HPP_NOEXCEPT + { + presentStage = presentStage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setTimeDomainId( uint64_t timeDomainId_ ) VULKAN_HPP_NOEXCEPT + { + timeDomainId = timeDomainId_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCalibratedTimestampInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainCalibratedTimestampInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, presentStage, timeDomainId ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainCalibratedTimestampInfoEXT const & ) const = default; +#else + bool operator==( SwapchainCalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( presentStage == rhs.presentStage ) && + ( timeDomainId == rhs.timeDomainId ); +# endif + } + + bool operator!=( SwapchainCalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainCalibratedTimestampInfoEXT; + const void * pNext = {}; + SwapchainKHR swapchain = {}; + PresentStageFlagsEXT presentStage = {}; + uint64_t timeDomainId = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainCalibratedTimestampInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainCalibratedTimestampInfoEXT; + }; + // wrapper struct for struct VkSwapchainCounterCreateInfoEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCounterCreateInfoEXT.html struct SwapchainCounterCreateInfoEXT @@ -154398,6 +155688,296 @@ namespace VULKAN_HPP_NAMESPACE using SwapchainPresentScalingCreateInfoEXT = SwapchainPresentScalingCreateInfoKHR; + // wrapper struct for struct VkSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainTimeDomainPropertiesEXT.html + struct SwapchainTimeDomainPropertiesEXT + { + using NativeType = VkSwapchainTimeDomainPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainTimeDomainPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainTimeDomainPropertiesEXT( uint32_t timeDomainCount_ = {}, + TimeDomainKHR * pTimeDomains_ = {}, + uint64_t * pTimeDomainIds_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , timeDomainCount{ timeDomainCount_ } + , pTimeDomains{ pTimeDomains_ } + , pTimeDomainIds{ pTimeDomainIds_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainTimeDomainPropertiesEXT( VkSwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainTimeDomainPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainTimeDomainPropertiesEXT( ArrayProxyNoTemporaries const & timeDomains_, + ArrayProxyNoTemporaries const & timeDomainIds_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , timeDomainCount( static_cast( timeDomains_.size() ) ) + , pTimeDomains( timeDomains_.data() ) + , pTimeDomainIds( timeDomainIds_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( timeDomains_.empty() || timeDomainIds_.empty() || ( timeDomains_.size() == timeDomainIds_.size() ) ); +# else + if ( !timeDomains_.empty() && !timeDomainIds_.empty() && ( timeDomains_.size() != timeDomainIds_.size() ) ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::SwapchainTimeDomainPropertiesEXT::SwapchainTimeDomainPropertiesEXT: !timeDomains_.empty() && !timeDomainIds_.empty() && ( timeDomains_.size() != timeDomainIds_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SwapchainTimeDomainPropertiesEXT & operator=( SwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainTimeDomainPropertiesEXT & operator=( VkSwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainTimeDomainPropertiesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainTimeDomainPropertiesEXT & setTimeDomainCount( uint32_t timeDomainCount_ ) VULKAN_HPP_NOEXCEPT + { + timeDomainCount = timeDomainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainTimeDomainPropertiesEXT & setPTimeDomains( TimeDomainKHR * pTimeDomains_ ) VULKAN_HPP_NOEXCEPT + { + pTimeDomains = pTimeDomains_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainTimeDomainPropertiesEXT & setTimeDomains( ArrayProxyNoTemporaries const & timeDomains_ ) VULKAN_HPP_NOEXCEPT + { + timeDomainCount = static_cast( timeDomains_.size() ); + pTimeDomains = timeDomains_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SwapchainTimeDomainPropertiesEXT & setPTimeDomainIds( uint64_t * pTimeDomainIds_ ) VULKAN_HPP_NOEXCEPT + { + pTimeDomainIds = pTimeDomainIds_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainTimeDomainPropertiesEXT & setTimeDomainIds( ArrayProxyNoTemporaries const & timeDomainIds_ ) VULKAN_HPP_NOEXCEPT + { + timeDomainCount = static_cast( timeDomainIds_.size() ); + pTimeDomainIds = timeDomainIds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainTimeDomainPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainTimeDomainPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainTimeDomainPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainTimeDomainPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timeDomainCount, pTimeDomains, pTimeDomainIds ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainTimeDomainPropertiesEXT const & ) const = default; +#else + bool operator==( SwapchainTimeDomainPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomainCount == rhs.timeDomainCount ) && ( pTimeDomains == rhs.pTimeDomains ) && + ( pTimeDomainIds == rhs.pTimeDomainIds ); +# endif + } + + bool operator!=( SwapchainTimeDomainPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainTimeDomainPropertiesEXT; + void * pNext = {}; + uint32_t timeDomainCount = {}; + TimeDomainKHR * pTimeDomains = {}; + uint64_t * pTimeDomainIds = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainTimeDomainPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainTimeDomainPropertiesEXT; + }; + + // wrapper struct for struct VkSwapchainTimingPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainTimingPropertiesEXT.html + struct SwapchainTimingPropertiesEXT + { + using NativeType = VkSwapchainTimingPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainTimingPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SwapchainTimingPropertiesEXT( uint64_t refreshDuration_ = {}, uint64_t refreshInterval_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , refreshDuration{ refreshDuration_ } + , refreshInterval{ refreshInterval_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainTimingPropertiesEXT( SwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainTimingPropertiesEXT( VkSwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainTimingPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainTimingPropertiesEXT & operator=( SwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainTimingPropertiesEXT & operator=( VkSwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainTimingPropertiesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainTimingPropertiesEXT & setRefreshDuration( uint64_t refreshDuration_ ) VULKAN_HPP_NOEXCEPT + { + refreshDuration = refreshDuration_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainTimingPropertiesEXT & setRefreshInterval( uint64_t refreshInterval_ ) VULKAN_HPP_NOEXCEPT + { + refreshInterval = refreshInterval_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainTimingPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainTimingPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainTimingPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainTimingPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, refreshDuration, refreshInterval ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainTimingPropertiesEXT const & ) const = default; +#else + bool operator==( SwapchainTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( refreshDuration == rhs.refreshDuration ) && ( refreshInterval == rhs.refreshInterval ); +# endif + } + + bool operator!=( SwapchainTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainTimingPropertiesEXT; + void * pNext = {}; + uint64_t refreshDuration = {}; + uint64_t refreshInterval = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainTimingPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainTimingPropertiesEXT; + }; + // wrapper struct for struct VkTensorCaptureDescriptorDataInfoARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCaptureDescriptorDataInfoARM.html struct TensorCaptureDescriptorDataInfoARM diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index 4502b2b..e918f7e 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -2260,6 +2260,8 @@ namespace VULKAN_HPP_NAMESPACE result += " Protected |"; if ( value & SwapchainCreateFlagBitsKHR::eMutableFormat ) result += " MutableFormat |"; + if ( value & SwapchainCreateFlagBitsKHR::ePresentTimingEXT ) + result += " PresentTimingEXT |"; if ( value & SwapchainCreateFlagBitsKHR::ePresentId2 ) result += " PresentId2 |"; if ( value & SwapchainCreateFlagBitsKHR::ePresentWait2 ) @@ -3205,6 +3207,57 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + //=== VK_EXT_present_timing === + + VULKAN_HPP_INLINE std::string to_string( PresentStageFlagsEXT value ) + { + std::string result = "{"; + if ( value & PresentStageFlagBitsEXT::eQueueOperationsEnd ) + result += " QueueOperationsEnd |"; + if ( value & PresentStageFlagBitsEXT::eRequestDequeued ) + result += " RequestDequeued |"; + if ( value & PresentStageFlagBitsEXT::eImageFirstPixelOut ) + result += " ImageFirstPixelOut |"; + if ( value & PresentStageFlagBitsEXT::eImageFirstPixelVisible ) + result += " ImageFirstPixelVisible |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PresentTimingInfoFlagsEXT value ) + { + std::string result = "{"; + if ( value & PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime ) + result += " PresentAtRelativeTime |"; + if ( value & PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle ) + result += " PresentAtNearestRefreshCycle |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PastPresentationTimingFlagsEXT value ) + { + std::string result = "{"; + if ( value & PastPresentationTimingFlagBitsEXT::eAllowPartialResults ) + result += " AllowPartialResults |"; + if ( value & PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults ) + result += " AllowOutOfOrderResults |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + #if defined( VK_USE_PLATFORM_FUCHSIA ) //=== VK_FUCHSIA_imagepipe_surface === @@ -4367,6 +4420,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorVideoProfileCodecNotSupportedKHR : return "ErrorVideoProfileCodecNotSupportedKHR"; case Result::eErrorVideoStdVersionNotSupportedKHR : return "ErrorVideoStdVersionNotSupportedKHR"; case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT"; + case Result::eErrorPresentTimingQueueFullEXT : return "ErrorPresentTimingQueueFullEXT"; #if defined( VK_USE_PLATFORM_WIN32_KHR ) case Result::eErrorFullScreenExclusiveModeLostEXT: return "ErrorFullScreenExclusiveModeLostEXT"; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -4950,6 +5004,16 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV"; case StructureType::eQueueFamilyCheckpointProperties2NV : return "QueueFamilyCheckpointProperties2NV"; case StructureType::eCheckpointData2NV : return "CheckpointData2NV"; + case StructureType::ePhysicalDevicePresentTimingFeaturesEXT : return "PhysicalDevicePresentTimingFeaturesEXT"; + case StructureType::eSwapchainTimingPropertiesEXT : return "SwapchainTimingPropertiesEXT"; + case StructureType::eSwapchainTimeDomainPropertiesEXT : return "SwapchainTimeDomainPropertiesEXT"; + case StructureType::ePresentTimingsInfoEXT : return "PresentTimingsInfoEXT"; + case StructureType::ePresentTimingInfoEXT : return "PresentTimingInfoEXT"; + case StructureType::ePastPresentationTimingInfoEXT : return "PastPresentationTimingInfoEXT"; + case StructureType::ePastPresentationTimingPropertiesEXT : return "PastPresentationTimingPropertiesEXT"; + case StructureType::ePastPresentationTimingEXT : return "PastPresentationTimingEXT"; + case StructureType::ePresentTimingSurfaceCapabilitiesEXT : return "PresentTimingSurfaceCapabilitiesEXT"; + case StructureType::eSwapchainCalibratedTimestampInfoEXT : return "SwapchainCalibratedTimestampInfoEXT"; case StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL: return "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"; case StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL : return "QueryPoolPerformanceQueryCreateInfoINTEL"; case StructureType::eInitializePerformanceApiInfoINTEL : return "InitializePerformanceApiInfoINTEL"; @@ -8140,6 +8204,7 @@ namespace VULKAN_HPP_NAMESPACE case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions"; case SwapchainCreateFlagBitsKHR::eProtected : return "Protected"; case SwapchainCreateFlagBitsKHR::eMutableFormat : return "MutableFormat"; + case SwapchainCreateFlagBitsKHR::ePresentTimingEXT : return "PresentTimingEXT"; case SwapchainCreateFlagBitsKHR::ePresentId2 : return "PresentId2"; case SwapchainCreateFlagBitsKHR::ePresentWait2 : return "PresentWait2"; case SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation: return "DeferredMemoryAllocation"; @@ -9192,6 +9257,40 @@ namespace VULKAN_HPP_NAMESPACE } } + //=== VK_EXT_present_timing === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentStageFlagBitsEXT value ) + { + switch ( value ) + { + case PresentStageFlagBitsEXT::eQueueOperationsEnd : return "QueueOperationsEnd"; + case PresentStageFlagBitsEXT::eRequestDequeued : return "RequestDequeued"; + case PresentStageFlagBitsEXT::eImageFirstPixelOut : return "ImageFirstPixelOut"; + case PresentStageFlagBitsEXT::eImageFirstPixelVisible: return "ImageFirstPixelVisible"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentTimingInfoFlagBitsEXT value ) + { + switch ( value ) + { + case PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime : return "PresentAtRelativeTime"; + case PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle: return "PresentAtNearestRefreshCycle"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PastPresentationTimingFlagBitsEXT value ) + { + switch ( value ) + { + case PastPresentationTimingFlagBitsEXT::eAllowPartialResults : return "AllowPartialResults"; + case PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults: return "AllowOutOfOrderResults"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + //=== VK_INTEL_performance_query === VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceConfigurationTypeINTEL value ) @@ -10510,6 +10609,8 @@ namespace VULKAN_HPP_NAMESPACE case TimeDomainKHR::eClockMonotonic : return "ClockMonotonic"; case TimeDomainKHR::eClockMonotonicRaw : return "ClockMonotonicRaw"; case TimeDomainKHR::eQueryPerformanceCounter: return "QueryPerformanceCounter"; + case TimeDomainKHR::ePresentStageLocalEXT : return "PresentStageLocalEXT"; + case TimeDomainKHR::eSwapchainLocalEXT : return "SwapchainLocalEXT"; default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } diff --git a/third_party/vulkan/vulkan_video.cppm b/third_party/vulkan/vulkan_video.cppm index 576bc5f..bcf3e54 100644 --- a/third_party/vulkan/vulkan_video.cppm +++ b/third_party/vulkan/vulkan_video.cppm @@ -4,315 +4,321 @@ // This header is generated from the Khronos Vulkan XML API Registry. -// Note: This module is still in an experimental state. -// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues. - module; +#define VULKAN_HPP_CXX_MODULE 1 + #include + +#if !defined( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) +# define VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING \ + "\n\tThe Vulkan-Hpp C++ named module is experimental. It is subject to change without prior notice.\n" \ + "\tTo silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n" \ + "\tFor feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues" + +VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) +#endif + #include -export module vulkan_video_hpp; +export module vulkan_hpp:video; -export namespace VULKAN_HPP_NAMESPACE +export namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE { - namespace VULKAN_HPP_VIDEO_NAMESPACE - { - //================= - //=== CONSTANTs === - //================= + //================= + //=== CONSTANTs === + //================= #if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CpbCntListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxChromaPlanes; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxNumListRef; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NoReferencePicture; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumLists; + //=== vulkan_video_codec_h264std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CpbCntListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxChromaPlanes; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxNumListRef; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NoReferencePicture; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumLists; #endif #if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCountListSize; + //=== vulkan_video_codec_h264std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCountListSize; #endif #if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileColsListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileRowsListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265CpbCntListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxChromaPlanes; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDeltaPoc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDpbSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermPics; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermRefPicsSps; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxNumListRef; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxShortTermRefPicSets; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265NoReferencePicture; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteCompEntriesListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteComponentsListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SublayersListSize; + //=== vulkan_video_codec_h265std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileColsListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileRowsListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265CpbCntListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxChromaPlanes; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDeltaPoc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDpbSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermPics; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermRefPicsSps; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxNumListRef; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxShortTermRefPicSets; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265NoReferencePicture; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteCompEntriesListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteComponentsListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SublayersListSize; #endif #if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) - //=== vulkan_video_codec_h265std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265RefPicSetListSize; + //=== vulkan_video_codec_h265std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265RefPicSetListSize; #endif #if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9LoopFilterAdjustments; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxRefFrames; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationPredProb; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationTreeProbs; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegments; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9NumRefFrames; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9RefsPerFrame; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9SegLvlMax; + //=== vulkan_video_codec_vp9std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9LoopFilterAdjustments; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxRefFrames; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationPredProb; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationTreeProbs; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegments; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9NumRefFrames; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9RefsPerFrame; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9SegLvlMax; #endif #if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1GlobalMotionParams; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1LoopFilterAdjustments; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxCdefFilterStrengths; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxLoopFilterStrengths; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCbPoints; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCrPoints; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPlanes; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosChroma; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosLuma; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumYPoints; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxSegments; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileCols; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileRows; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1NumRefFrames; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1PrimaryRefNone; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1RefsPerFrame; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SegLvlMax; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectIntegerMv; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectScreenContentTools; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SkipModeFrames; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1TotalRefsPerFrame; + //=== vulkan_video_codec_av1std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1GlobalMotionParams; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1LoopFilterAdjustments; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxCdefFilterStrengths; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxLoopFilterStrengths; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCbPoints; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCrPoints; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPlanes; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosChroma; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosLuma; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumYPoints; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxSegments; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileCols; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileRows; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1NumRefFrames; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1PrimaryRefNone; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1RefsPerFrame; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SegLvlMax; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectIntegerMv; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectScreenContentTools; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SkipModeFrames; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1TotalRefsPerFrame; #endif - //============= - //=== ENUMs === - //============= + //============= + //=== ENUMs === + //============= #if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc; + //=== vulkan_video_codec_h264std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc; #endif #if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount; + //=== vulkan_video_codec_h264std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount; #endif #if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType; + //=== vulkan_video_codec_h265std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType; #endif #if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Level; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ReferenceName; + //=== vulkan_video_codec_vp9std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Level; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ReferenceName; #endif #if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode; + //=== vulkan_video_codec_av1std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode; #endif - //=============== - //=== STRUCTS === - //=============== + //=============== + //=== STRUCTS === + //=============== #if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags; + //=== vulkan_video_codec_h264std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags; #endif #if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags; + //=== vulkan_video_codec_h264std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags; #endif #if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ ) - //=== vulkan_video_codec_h264std_encode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags; + //=== vulkan_video_codec_h264std_encode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags; #endif #if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags; + //=== vulkan_video_codec_h265std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags; #endif #if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) - //=== vulkan_video_codec_h265std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags; + //=== vulkan_video_codec_h265std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags; #endif #if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ ) - //=== vulkan_video_codec_h265std_encode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags; + //=== vulkan_video_codec_h265std_encode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags; #endif #if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags; + //=== vulkan_video_codec_vp9std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags; #endif #if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ ) - //=== vulkan_video_codec_vp9std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags; + //=== vulkan_video_codec_vp9std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags; #endif #if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags; + //=== vulkan_video_codec_av1std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags; #endif #if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ ) - //=== vulkan_video_codec_av1std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags; + //=== vulkan_video_codec_av1std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags; #endif #if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ ) - //=== vulkan_video_codec_av1std_encode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags; + //=== vulkan_video_codec_av1std_encode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags; #endif - } // namespace VULKAN_HPP_VIDEO_NAMESPACE -} // namespace VULKAN_HPP_NAMESPACE +} // namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE