From eadd73ba1476fea152cd0bdf9a956b8b593442bf Mon Sep 17 00:00:00 2001 From: ziga-lunarg Date: Fri, 28 Nov 2025 10:37:15 +0200 Subject: [PATCH] build: Update to header 1.4.335 --- CMakeLists.txt | 2 +- include/vulkan/utility/vk_dispatch_table.h | 8 + include/vulkan/utility/vk_safe_struct.hpp | 193 +++++ include/vulkan/utility/vk_struct_helper.hpp | 10 + include/vulkan/vk_enum_string_helper.h | 133 ++++ scripts/known_good.json | 2 +- src/vulkan/vk_safe_struct_ext.cpp | 793 ++++++++++++++++++++ src/vulkan/vk_safe_struct_utils.cpp | 24 + 8 files changed, 1163 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e98e7e6..d72732e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.22.1) # The VERSION field is generated with the "--generated-version" flag in the generate_source.py script -project(VUL VERSION 1.4.334 LANGUAGES CXX) +project(VUL VERSION 1.4.335 LANGUAGES CXX) set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Remove when min is 3.26, see CMP0143 diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h index 0d14154..3fd0b9e 100644 --- a/include/vulkan/utility/vk_dispatch_table.h +++ b/include/vulkan/utility/vk_dispatch_table.h @@ -598,6 +598,10 @@ typedef struct VkuDeviceDispatchTable_ { PFN_vkCmdSetCheckpointNV CmdSetCheckpointNV; PFN_vkGetQueueCheckpointDataNV GetQueueCheckpointDataNV; PFN_vkGetQueueCheckpointData2NV GetQueueCheckpointData2NV; + PFN_vkSetSwapchainPresentTimingQueueSizeEXT SetSwapchainPresentTimingQueueSizeEXT; + PFN_vkGetSwapchainTimingPropertiesEXT GetSwapchainTimingPropertiesEXT; + PFN_vkGetSwapchainTimeDomainPropertiesEXT GetSwapchainTimeDomainPropertiesEXT; + PFN_vkGetPastPresentationTimingEXT GetPastPresentationTimingEXT; PFN_vkInitializePerformanceApiINTEL InitializePerformanceApiINTEL; PFN_vkUninitializePerformanceApiINTEL UninitializePerformanceApiINTEL; PFN_vkCmdSetPerformanceMarkerINTEL CmdSetPerformanceMarkerINTEL; @@ -1286,6 +1290,10 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch table->CmdSetCheckpointNV = (PFN_vkCmdSetCheckpointNV)gdpa(device, "vkCmdSetCheckpointNV"); table->GetQueueCheckpointDataNV = (PFN_vkGetQueueCheckpointDataNV)gdpa(device, "vkGetQueueCheckpointDataNV"); table->GetQueueCheckpointData2NV = (PFN_vkGetQueueCheckpointData2NV)gdpa(device, "vkGetQueueCheckpointData2NV"); + table->SetSwapchainPresentTimingQueueSizeEXT = (PFN_vkSetSwapchainPresentTimingQueueSizeEXT)gdpa(device, "vkSetSwapchainPresentTimingQueueSizeEXT"); + table->GetSwapchainTimingPropertiesEXT = (PFN_vkGetSwapchainTimingPropertiesEXT)gdpa(device, "vkGetSwapchainTimingPropertiesEXT"); + table->GetSwapchainTimeDomainPropertiesEXT = (PFN_vkGetSwapchainTimeDomainPropertiesEXT)gdpa(device, "vkGetSwapchainTimeDomainPropertiesEXT"); + table->GetPastPresentationTimingEXT = (PFN_vkGetPastPresentationTimingEXT)gdpa(device, "vkGetPastPresentationTimingEXT"); table->InitializePerformanceApiINTEL = (PFN_vkInitializePerformanceApiINTEL)gdpa(device, "vkInitializePerformanceApiINTEL"); table->UninitializePerformanceApiINTEL = (PFN_vkUninitializePerformanceApiINTEL)gdpa(device, "vkUninitializePerformanceApiINTEL"); table->CmdSetPerformanceMarkerINTEL = (PFN_vkCmdSetPerformanceMarkerINTEL)gdpa(device, "vkCmdSetPerformanceMarkerINTEL"); diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 204df2e..cbb0888 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -13193,6 +13193,199 @@ struct safe_VkCheckpointData2NV { VkCheckpointData2NV* ptr() { return reinterpret_cast(this); } VkCheckpointData2NV const* ptr() const { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDevicePresentTimingFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 presentTiming; + VkBool32 presentAtAbsoluteTime; + VkBool32 presentAtRelativeTime; + + safe_VkPhysicalDevicePresentTimingFeaturesEXT(const VkPhysicalDevicePresentTimingFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePresentTimingFeaturesEXT(const safe_VkPhysicalDevicePresentTimingFeaturesEXT& copy_src); + safe_VkPhysicalDevicePresentTimingFeaturesEXT& operator=(const safe_VkPhysicalDevicePresentTimingFeaturesEXT& copy_src); + safe_VkPhysicalDevicePresentTimingFeaturesEXT(); + ~safe_VkPhysicalDevicePresentTimingFeaturesEXT(); + void initialize(const VkPhysicalDevicePresentTimingFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePresentTimingFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePresentTimingFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePresentTimingFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPresentTimingSurfaceCapabilitiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 presentTimingSupported; + VkBool32 presentAtAbsoluteTimeSupported; + VkBool32 presentAtRelativeTimeSupported; + VkPresentStageFlagsEXT presentStageQueries; + + safe_VkPresentTimingSurfaceCapabilitiesEXT(const VkPresentTimingSurfaceCapabilitiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentTimingSurfaceCapabilitiesEXT(const safe_VkPresentTimingSurfaceCapabilitiesEXT& copy_src); + safe_VkPresentTimingSurfaceCapabilitiesEXT& operator=(const safe_VkPresentTimingSurfaceCapabilitiesEXT& copy_src); + safe_VkPresentTimingSurfaceCapabilitiesEXT(); + ~safe_VkPresentTimingSurfaceCapabilitiesEXT(); + void initialize(const VkPresentTimingSurfaceCapabilitiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentTimingSurfaceCapabilitiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPresentTimingSurfaceCapabilitiesEXT* ptr() { return reinterpret_cast(this); } + VkPresentTimingSurfaceCapabilitiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSwapchainCalibratedTimestampInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkSwapchainKHR swapchain; + VkPresentStageFlagsEXT presentStage; + uint64_t timeDomainId; + + safe_VkSwapchainCalibratedTimestampInfoEXT(const VkSwapchainCalibratedTimestampInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSwapchainCalibratedTimestampInfoEXT(const safe_VkSwapchainCalibratedTimestampInfoEXT& copy_src); + safe_VkSwapchainCalibratedTimestampInfoEXT& operator=(const safe_VkSwapchainCalibratedTimestampInfoEXT& copy_src); + safe_VkSwapchainCalibratedTimestampInfoEXT(); + ~safe_VkSwapchainCalibratedTimestampInfoEXT(); + void initialize(const VkSwapchainCalibratedTimestampInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainCalibratedTimestampInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainCalibratedTimestampInfoEXT* ptr() { return reinterpret_cast(this); } + VkSwapchainCalibratedTimestampInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSwapchainTimingPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint64_t refreshDuration; + uint64_t refreshInterval; + + safe_VkSwapchainTimingPropertiesEXT(const VkSwapchainTimingPropertiesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSwapchainTimingPropertiesEXT(const safe_VkSwapchainTimingPropertiesEXT& copy_src); + safe_VkSwapchainTimingPropertiesEXT& operator=(const safe_VkSwapchainTimingPropertiesEXT& copy_src); + safe_VkSwapchainTimingPropertiesEXT(); + ~safe_VkSwapchainTimingPropertiesEXT(); + void initialize(const VkSwapchainTimingPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainTimingPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainTimingPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkSwapchainTimingPropertiesEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSwapchainTimeDomainPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t timeDomainCount; + VkTimeDomainKHR* pTimeDomains{}; + uint64_t* pTimeDomainIds{}; + + safe_VkSwapchainTimeDomainPropertiesEXT(const VkSwapchainTimeDomainPropertiesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSwapchainTimeDomainPropertiesEXT(const safe_VkSwapchainTimeDomainPropertiesEXT& copy_src); + safe_VkSwapchainTimeDomainPropertiesEXT& operator=(const safe_VkSwapchainTimeDomainPropertiesEXT& copy_src); + safe_VkSwapchainTimeDomainPropertiesEXT(); + ~safe_VkSwapchainTimeDomainPropertiesEXT(); + void initialize(const VkSwapchainTimeDomainPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainTimeDomainPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainTimeDomainPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkSwapchainTimeDomainPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPastPresentationTimingInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPastPresentationTimingFlagsEXT flags; + VkSwapchainKHR swapchain; + + safe_VkPastPresentationTimingInfoEXT(const VkPastPresentationTimingInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPastPresentationTimingInfoEXT(const safe_VkPastPresentationTimingInfoEXT& copy_src); + safe_VkPastPresentationTimingInfoEXT& operator=(const safe_VkPastPresentationTimingInfoEXT& copy_src); + safe_VkPastPresentationTimingInfoEXT(); + ~safe_VkPastPresentationTimingInfoEXT(); + void initialize(const VkPastPresentationTimingInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPastPresentationTimingInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPastPresentationTimingInfoEXT* ptr() { return reinterpret_cast(this); } + VkPastPresentationTimingInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPastPresentationTimingEXT { + VkStructureType sType; + void* pNext{}; + uint64_t presentId; + uint64_t targetTime; + uint32_t presentStageCount; + VkPresentStageTimeEXT* pPresentStages{}; + VkTimeDomainKHR timeDomain; + uint64_t timeDomainId; + VkBool32 reportComplete; + + safe_VkPastPresentationTimingEXT(const VkPastPresentationTimingEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPastPresentationTimingEXT(const safe_VkPastPresentationTimingEXT& copy_src); + safe_VkPastPresentationTimingEXT& operator=(const safe_VkPastPresentationTimingEXT& copy_src); + safe_VkPastPresentationTimingEXT(); + ~safe_VkPastPresentationTimingEXT(); + void initialize(const VkPastPresentationTimingEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPastPresentationTimingEXT* copy_src, PNextCopyState* copy_state = {}); + VkPastPresentationTimingEXT* ptr() { return reinterpret_cast(this); } + VkPastPresentationTimingEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPastPresentationTimingPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint64_t timingPropertiesCounter; + uint64_t timeDomainsCounter; + uint32_t presentationTimingCount; + safe_VkPastPresentationTimingEXT* pPresentationTimings{}; + + safe_VkPastPresentationTimingPropertiesEXT(const VkPastPresentationTimingPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPastPresentationTimingPropertiesEXT(const safe_VkPastPresentationTimingPropertiesEXT& copy_src); + safe_VkPastPresentationTimingPropertiesEXT& operator=(const safe_VkPastPresentationTimingPropertiesEXT& copy_src); + safe_VkPastPresentationTimingPropertiesEXT(); + ~safe_VkPastPresentationTimingPropertiesEXT(); + void initialize(const VkPastPresentationTimingPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPastPresentationTimingPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPastPresentationTimingPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkPastPresentationTimingPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPresentTimingInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPresentTimingInfoFlagsEXT flags; + uint64_t targetTime; + uint64_t timeDomainId; + VkPresentStageFlagsEXT presentStageQueries; + VkPresentStageFlagsEXT targetTimeDomainPresentStage; + + safe_VkPresentTimingInfoEXT(const VkPresentTimingInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentTimingInfoEXT(const safe_VkPresentTimingInfoEXT& copy_src); + safe_VkPresentTimingInfoEXT& operator=(const safe_VkPresentTimingInfoEXT& copy_src); + safe_VkPresentTimingInfoEXT(); + ~safe_VkPresentTimingInfoEXT(); + void initialize(const VkPresentTimingInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentTimingInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPresentTimingInfoEXT* ptr() { return reinterpret_cast(this); } + VkPresentTimingInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPresentTimingsInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t swapchainCount; + safe_VkPresentTimingInfoEXT* pTimingInfos{}; + + safe_VkPresentTimingsInfoEXT(const VkPresentTimingsInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentTimingsInfoEXT(const safe_VkPresentTimingsInfoEXT& copy_src); + safe_VkPresentTimingsInfoEXT& operator=(const safe_VkPresentTimingsInfoEXT& copy_src); + safe_VkPresentTimingsInfoEXT(); + ~safe_VkPresentTimingsInfoEXT(); + void initialize(const VkPresentTimingsInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentTimingsInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPresentTimingsInfoEXT* ptr() { return reinterpret_cast(this); } + VkPresentTimingsInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; struct safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { VkStructureType sType; void* pNext{}; diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp index 134a9a1..4ffdba7 100644 --- a/include/vulkan/utility/vk_struct_helper.hpp +++ b/include/vulkan/utility/vk_struct_helper.hpp @@ -696,6 +696,16 @@ template <> inline VkStructureType GetSType template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; } diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index a1debb7..fdb8917 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -94,6 +94,8 @@ static inline const char* string_VkResult(VkResult input_value) { return "VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR"; case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"; + case VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT: + return "VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT"; case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"; case VK_THREAD_IDLE_KHR: @@ -1182,6 +1184,26 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"; case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: + return "VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT"; + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: + return "VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT"; + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + return "VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT"; + case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: + return "VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT"; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: + return "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT"; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: + return "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT"; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: + return "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT"; + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + return "VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT"; + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + return "VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"; case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: @@ -4432,6 +4454,10 @@ static inline const char* string_VkTimeDomainKHR(VkTimeDomainKHR input_value) { return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR"; case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR: return "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR"; + case VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT: + return "VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT"; + case VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT: + return "VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT"; default: return "Unhandled VkTimeDomainKHR"; } @@ -8472,6 +8498,8 @@ static inline const char* string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateF return "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR"; case VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR: return "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"; + case VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT: + return "VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT"; case VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR: return "VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR"; case VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR: @@ -10061,6 +10089,91 @@ static inline std::string string_VkBuildAccelerationStructureFlagsKHR(VkBuildAcc return ret; } #endif // __cplusplus +static inline const char* string_VkPresentStageFlagBitsEXT(VkPresentStageFlagBitsEXT input_value) { + switch (input_value) { + case VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT: + return "VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT"; + case VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT: + return "VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT"; + case VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT: + return "VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT"; + case VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT: + return "VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT"; + default: + return "Unhandled VkPresentStageFlagBitsEXT"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkPresentStageFlagsEXT(VkPresentStageFlagsEXT input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkPresentStageFlagBitsEXT(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkPresentStageFlagsEXT(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkPastPresentationTimingFlagBitsEXT(VkPastPresentationTimingFlagBitsEXT input_value) { + switch (input_value) { + case VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT: + return "VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT"; + case VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT: + return "VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT"; + default: + return "Unhandled VkPastPresentationTimingFlagBitsEXT"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkPastPresentationTimingFlagsEXT(VkPastPresentationTimingFlagsEXT input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkPastPresentationTimingFlagBitsEXT(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkPastPresentationTimingFlagsEXT(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkPresentTimingInfoFlagBitsEXT(VkPresentTimingInfoFlagBitsEXT input_value) { + switch (input_value) { + case VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT: + return "VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT"; + case VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT: + return "VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT"; + default: + return "Unhandled VkPresentTimingInfoFlagBitsEXT"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkPresentTimingInfoFlagsEXT(VkPresentTimingInfoFlagsEXT input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkPresentTimingInfoFlagBitsEXT(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkPresentTimingInfoFlagsEXT(0)"); + return ret; +} +#endif // __cplusplus static inline const char* string_VkIndirectStateFlagBitsNV(VkIndirectStateFlagBitsNV input_value) { switch (input_value) { case VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV: @@ -12460,6 +12573,26 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkQueueFamilyCheckpointProperties2NV"; case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: return "VkCheckpointData2NV"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + return "VkPhysicalDevicePresentTimingFeaturesEXT"; + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + return "VkPresentTimingSurfaceCapabilitiesEXT"; + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + return "VkSwapchainCalibratedTimestampInfoEXT"; + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: + return "VkSwapchainTimingPropertiesEXT"; + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: + return "VkSwapchainTimeDomainPropertiesEXT"; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: + return "VkPastPresentationTimingInfoEXT"; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: + return "VkPastPresentationTimingEXT"; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: + return "VkPastPresentationTimingPropertiesEXT"; + case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: + return "VkPresentTimingInfoEXT"; + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + return "VkPresentTimingsInfoEXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: return "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"; case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: diff --git a/scripts/known_good.json b/scripts/known_good.json index 1e94363..4d13f41 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -7,7 +7,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.4.334" + "commit": "v1.4.335" }, { "name": "googletest", diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp index eadf873..7fa0441 100644 --- a/src/vulkan/vk_safe_struct_ext.cpp +++ b/src/vulkan/vk_safe_struct_ext.cpp @@ -4033,6 +4033,799 @@ void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize( pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDevicePresentTimingFeaturesEXT::safe_VkPhysicalDevicePresentTimingFeaturesEXT( + const VkPhysicalDevicePresentTimingFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + presentTiming(in_struct->presentTiming), + presentAtAbsoluteTime(in_struct->presentAtAbsoluteTime), + presentAtRelativeTime(in_struct->presentAtRelativeTime) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePresentTimingFeaturesEXT::safe_VkPhysicalDevicePresentTimingFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT), + pNext(nullptr), + presentTiming(), + presentAtAbsoluteTime(), + presentAtRelativeTime() {} + +safe_VkPhysicalDevicePresentTimingFeaturesEXT::safe_VkPhysicalDevicePresentTimingFeaturesEXT( + const safe_VkPhysicalDevicePresentTimingFeaturesEXT& copy_src) { + sType = copy_src.sType; + presentTiming = copy_src.presentTiming; + presentAtAbsoluteTime = copy_src.presentAtAbsoluteTime; + presentAtRelativeTime = copy_src.presentAtRelativeTime; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePresentTimingFeaturesEXT& safe_VkPhysicalDevicePresentTimingFeaturesEXT::operator=( + const safe_VkPhysicalDevicePresentTimingFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentTiming = copy_src.presentTiming; + presentAtAbsoluteTime = copy_src.presentAtAbsoluteTime; + presentAtRelativeTime = copy_src.presentAtRelativeTime; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePresentTimingFeaturesEXT::~safe_VkPhysicalDevicePresentTimingFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePresentTimingFeaturesEXT::initialize(const VkPhysicalDevicePresentTimingFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentTiming = in_struct->presentTiming; + presentAtAbsoluteTime = in_struct->presentAtAbsoluteTime; + presentAtRelativeTime = in_struct->presentAtRelativeTime; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePresentTimingFeaturesEXT::initialize(const safe_VkPhysicalDevicePresentTimingFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentTiming = copy_src->presentTiming; + presentAtAbsoluteTime = copy_src->presentAtAbsoluteTime; + presentAtRelativeTime = copy_src->presentAtRelativeTime; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPresentTimingSurfaceCapabilitiesEXT::safe_VkPresentTimingSurfaceCapabilitiesEXT( + const VkPresentTimingSurfaceCapabilitiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + presentTimingSupported(in_struct->presentTimingSupported), + presentAtAbsoluteTimeSupported(in_struct->presentAtAbsoluteTimeSupported), + presentAtRelativeTimeSupported(in_struct->presentAtRelativeTimeSupported), + presentStageQueries(in_struct->presentStageQueries) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPresentTimingSurfaceCapabilitiesEXT::safe_VkPresentTimingSurfaceCapabilitiesEXT() + : sType(VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT), + pNext(nullptr), + presentTimingSupported(), + presentAtAbsoluteTimeSupported(), + presentAtRelativeTimeSupported(), + presentStageQueries() {} + +safe_VkPresentTimingSurfaceCapabilitiesEXT::safe_VkPresentTimingSurfaceCapabilitiesEXT( + const safe_VkPresentTimingSurfaceCapabilitiesEXT& copy_src) { + sType = copy_src.sType; + presentTimingSupported = copy_src.presentTimingSupported; + presentAtAbsoluteTimeSupported = copy_src.presentAtAbsoluteTimeSupported; + presentAtRelativeTimeSupported = copy_src.presentAtRelativeTimeSupported; + presentStageQueries = copy_src.presentStageQueries; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPresentTimingSurfaceCapabilitiesEXT& safe_VkPresentTimingSurfaceCapabilitiesEXT::operator=( + const safe_VkPresentTimingSurfaceCapabilitiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentTimingSupported = copy_src.presentTimingSupported; + presentAtAbsoluteTimeSupported = copy_src.presentAtAbsoluteTimeSupported; + presentAtRelativeTimeSupported = copy_src.presentAtRelativeTimeSupported; + presentStageQueries = copy_src.presentStageQueries; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPresentTimingSurfaceCapabilitiesEXT::~safe_VkPresentTimingSurfaceCapabilitiesEXT() { FreePnextChain(pNext); } + +void safe_VkPresentTimingSurfaceCapabilitiesEXT::initialize(const VkPresentTimingSurfaceCapabilitiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentTimingSupported = in_struct->presentTimingSupported; + presentAtAbsoluteTimeSupported = in_struct->presentAtAbsoluteTimeSupported; + presentAtRelativeTimeSupported = in_struct->presentAtRelativeTimeSupported; + presentStageQueries = in_struct->presentStageQueries; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPresentTimingSurfaceCapabilitiesEXT::initialize(const safe_VkPresentTimingSurfaceCapabilitiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentTimingSupported = copy_src->presentTimingSupported; + presentAtAbsoluteTimeSupported = copy_src->presentAtAbsoluteTimeSupported; + presentAtRelativeTimeSupported = copy_src->presentAtRelativeTimeSupported; + presentStageQueries = copy_src->presentStageQueries; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSwapchainCalibratedTimestampInfoEXT::safe_VkSwapchainCalibratedTimestampInfoEXT( + const VkSwapchainCalibratedTimestampInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + swapchain(in_struct->swapchain), + presentStage(in_struct->presentStage), + timeDomainId(in_struct->timeDomainId) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSwapchainCalibratedTimestampInfoEXT::safe_VkSwapchainCalibratedTimestampInfoEXT() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT), + pNext(nullptr), + swapchain(), + presentStage(), + timeDomainId() {} + +safe_VkSwapchainCalibratedTimestampInfoEXT::safe_VkSwapchainCalibratedTimestampInfoEXT( + const safe_VkSwapchainCalibratedTimestampInfoEXT& copy_src) { + sType = copy_src.sType; + swapchain = copy_src.swapchain; + presentStage = copy_src.presentStage; + timeDomainId = copy_src.timeDomainId; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSwapchainCalibratedTimestampInfoEXT& safe_VkSwapchainCalibratedTimestampInfoEXT::operator=( + const safe_VkSwapchainCalibratedTimestampInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchain = copy_src.swapchain; + presentStage = copy_src.presentStage; + timeDomainId = copy_src.timeDomainId; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSwapchainCalibratedTimestampInfoEXT::~safe_VkSwapchainCalibratedTimestampInfoEXT() { FreePnextChain(pNext); } + +void safe_VkSwapchainCalibratedTimestampInfoEXT::initialize(const VkSwapchainCalibratedTimestampInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + swapchain = in_struct->swapchain; + presentStage = in_struct->presentStage; + timeDomainId = in_struct->timeDomainId; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSwapchainCalibratedTimestampInfoEXT::initialize(const safe_VkSwapchainCalibratedTimestampInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchain = copy_src->swapchain; + presentStage = copy_src->presentStage; + timeDomainId = copy_src->timeDomainId; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSwapchainTimingPropertiesEXT::safe_VkSwapchainTimingPropertiesEXT(const VkSwapchainTimingPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), refreshDuration(in_struct->refreshDuration), refreshInterval(in_struct->refreshInterval) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSwapchainTimingPropertiesEXT::safe_VkSwapchainTimingPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT), pNext(nullptr), refreshDuration(), refreshInterval() {} + +safe_VkSwapchainTimingPropertiesEXT::safe_VkSwapchainTimingPropertiesEXT(const safe_VkSwapchainTimingPropertiesEXT& copy_src) { + sType = copy_src.sType; + refreshDuration = copy_src.refreshDuration; + refreshInterval = copy_src.refreshInterval; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSwapchainTimingPropertiesEXT& safe_VkSwapchainTimingPropertiesEXT::operator=( + const safe_VkSwapchainTimingPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + refreshDuration = copy_src.refreshDuration; + refreshInterval = copy_src.refreshInterval; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSwapchainTimingPropertiesEXT::~safe_VkSwapchainTimingPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkSwapchainTimingPropertiesEXT::initialize(const VkSwapchainTimingPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + refreshDuration = in_struct->refreshDuration; + refreshInterval = in_struct->refreshInterval; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSwapchainTimingPropertiesEXT::initialize(const safe_VkSwapchainTimingPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + refreshDuration = copy_src->refreshDuration; + refreshInterval = copy_src->refreshInterval; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSwapchainTimeDomainPropertiesEXT::safe_VkSwapchainTimeDomainPropertiesEXT( + const VkSwapchainTimeDomainPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), timeDomainCount(in_struct->timeDomainCount), pTimeDomains(nullptr), pTimeDomainIds(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pTimeDomains) { + pTimeDomains = new VkTimeDomainKHR[in_struct->timeDomainCount]; + memcpy((void*)pTimeDomains, (void*)in_struct->pTimeDomains, sizeof(VkTimeDomainKHR) * in_struct->timeDomainCount); + } + + if (in_struct->pTimeDomainIds) { + pTimeDomainIds = new uint64_t[in_struct->timeDomainCount]; + memcpy((void*)pTimeDomainIds, (void*)in_struct->pTimeDomainIds, sizeof(uint64_t) * in_struct->timeDomainCount); + } +} + +safe_VkSwapchainTimeDomainPropertiesEXT::safe_VkSwapchainTimeDomainPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT), + pNext(nullptr), + timeDomainCount(), + pTimeDomains(nullptr), + pTimeDomainIds(nullptr) {} + +safe_VkSwapchainTimeDomainPropertiesEXT::safe_VkSwapchainTimeDomainPropertiesEXT( + const safe_VkSwapchainTimeDomainPropertiesEXT& copy_src) { + sType = copy_src.sType; + timeDomainCount = copy_src.timeDomainCount; + pTimeDomains = nullptr; + pTimeDomainIds = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pTimeDomains) { + pTimeDomains = new VkTimeDomainKHR[copy_src.timeDomainCount]; + memcpy((void*)pTimeDomains, (void*)copy_src.pTimeDomains, sizeof(VkTimeDomainKHR) * copy_src.timeDomainCount); + } + + if (copy_src.pTimeDomainIds) { + pTimeDomainIds = new uint64_t[copy_src.timeDomainCount]; + memcpy((void*)pTimeDomainIds, (void*)copy_src.pTimeDomainIds, sizeof(uint64_t) * copy_src.timeDomainCount); + } +} + +safe_VkSwapchainTimeDomainPropertiesEXT& safe_VkSwapchainTimeDomainPropertiesEXT::operator=( + const safe_VkSwapchainTimeDomainPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + if (pTimeDomains) delete[] pTimeDomains; + if (pTimeDomainIds) delete[] pTimeDomainIds; + FreePnextChain(pNext); + + sType = copy_src.sType; + timeDomainCount = copy_src.timeDomainCount; + pTimeDomains = nullptr; + pTimeDomainIds = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pTimeDomains) { + pTimeDomains = new VkTimeDomainKHR[copy_src.timeDomainCount]; + memcpy((void*)pTimeDomains, (void*)copy_src.pTimeDomains, sizeof(VkTimeDomainKHR) * copy_src.timeDomainCount); + } + + if (copy_src.pTimeDomainIds) { + pTimeDomainIds = new uint64_t[copy_src.timeDomainCount]; + memcpy((void*)pTimeDomainIds, (void*)copy_src.pTimeDomainIds, sizeof(uint64_t) * copy_src.timeDomainCount); + } + + return *this; +} + +safe_VkSwapchainTimeDomainPropertiesEXT::~safe_VkSwapchainTimeDomainPropertiesEXT() { + if (pTimeDomains) delete[] pTimeDomains; + if (pTimeDomainIds) delete[] pTimeDomainIds; + FreePnextChain(pNext); +} + +void safe_VkSwapchainTimeDomainPropertiesEXT::initialize(const VkSwapchainTimeDomainPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTimeDomains) delete[] pTimeDomains; + if (pTimeDomainIds) delete[] pTimeDomainIds; + FreePnextChain(pNext); + sType = in_struct->sType; + timeDomainCount = in_struct->timeDomainCount; + pTimeDomains = nullptr; + pTimeDomainIds = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pTimeDomains) { + pTimeDomains = new VkTimeDomainKHR[in_struct->timeDomainCount]; + memcpy((void*)pTimeDomains, (void*)in_struct->pTimeDomains, sizeof(VkTimeDomainKHR) * in_struct->timeDomainCount); + } + + if (in_struct->pTimeDomainIds) { + pTimeDomainIds = new uint64_t[in_struct->timeDomainCount]; + memcpy((void*)pTimeDomainIds, (void*)in_struct->pTimeDomainIds, sizeof(uint64_t) * in_struct->timeDomainCount); + } +} + +void safe_VkSwapchainTimeDomainPropertiesEXT::initialize(const safe_VkSwapchainTimeDomainPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + timeDomainCount = copy_src->timeDomainCount; + pTimeDomains = nullptr; + pTimeDomainIds = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pTimeDomains) { + pTimeDomains = new VkTimeDomainKHR[copy_src->timeDomainCount]; + memcpy((void*)pTimeDomains, (void*)copy_src->pTimeDomains, sizeof(VkTimeDomainKHR) * copy_src->timeDomainCount); + } + + if (copy_src->pTimeDomainIds) { + pTimeDomainIds = new uint64_t[copy_src->timeDomainCount]; + memcpy((void*)pTimeDomainIds, (void*)copy_src->pTimeDomainIds, sizeof(uint64_t) * copy_src->timeDomainCount); + } +} + +safe_VkPastPresentationTimingInfoEXT::safe_VkPastPresentationTimingInfoEXT(const VkPastPresentationTimingInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), swapchain(in_struct->swapchain) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPastPresentationTimingInfoEXT::safe_VkPastPresentationTimingInfoEXT() + : sType(VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT), pNext(nullptr), flags(), swapchain() {} + +safe_VkPastPresentationTimingInfoEXT::safe_VkPastPresentationTimingInfoEXT(const safe_VkPastPresentationTimingInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + swapchain = copy_src.swapchain; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPastPresentationTimingInfoEXT& safe_VkPastPresentationTimingInfoEXT::operator=( + const safe_VkPastPresentationTimingInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + swapchain = copy_src.swapchain; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPastPresentationTimingInfoEXT::~safe_VkPastPresentationTimingInfoEXT() { FreePnextChain(pNext); } + +void safe_VkPastPresentationTimingInfoEXT::initialize(const VkPastPresentationTimingInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + swapchain = in_struct->swapchain; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPastPresentationTimingInfoEXT::initialize(const safe_VkPastPresentationTimingInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + swapchain = copy_src->swapchain; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPastPresentationTimingEXT::safe_VkPastPresentationTimingEXT(const VkPastPresentationTimingEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + presentId(in_struct->presentId), + targetTime(in_struct->targetTime), + presentStageCount(in_struct->presentStageCount), + pPresentStages(nullptr), + timeDomain(in_struct->timeDomain), + timeDomainId(in_struct->timeDomainId), + reportComplete(in_struct->reportComplete) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPresentStages) { + pPresentStages = new VkPresentStageTimeEXT[in_struct->presentStageCount]; + memcpy((void*)pPresentStages, (void*)in_struct->pPresentStages, + sizeof(VkPresentStageTimeEXT) * in_struct->presentStageCount); + } +} + +safe_VkPastPresentationTimingEXT::safe_VkPastPresentationTimingEXT() + : sType(VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT), + pNext(nullptr), + presentId(), + targetTime(), + presentStageCount(), + pPresentStages(nullptr), + timeDomain(), + timeDomainId(), + reportComplete() {} + +safe_VkPastPresentationTimingEXT::safe_VkPastPresentationTimingEXT(const safe_VkPastPresentationTimingEXT& copy_src) { + sType = copy_src.sType; + presentId = copy_src.presentId; + targetTime = copy_src.targetTime; + presentStageCount = copy_src.presentStageCount; + pPresentStages = nullptr; + timeDomain = copy_src.timeDomain; + timeDomainId = copy_src.timeDomainId; + reportComplete = copy_src.reportComplete; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentStages) { + pPresentStages = new VkPresentStageTimeEXT[copy_src.presentStageCount]; + memcpy((void*)pPresentStages, (void*)copy_src.pPresentStages, sizeof(VkPresentStageTimeEXT) * copy_src.presentStageCount); + } +} + +safe_VkPastPresentationTimingEXT& safe_VkPastPresentationTimingEXT::operator=(const safe_VkPastPresentationTimingEXT& copy_src) { + if (©_src == this) return *this; + + if (pPresentStages) delete[] pPresentStages; + FreePnextChain(pNext); + + sType = copy_src.sType; + presentId = copy_src.presentId; + targetTime = copy_src.targetTime; + presentStageCount = copy_src.presentStageCount; + pPresentStages = nullptr; + timeDomain = copy_src.timeDomain; + timeDomainId = copy_src.timeDomainId; + reportComplete = copy_src.reportComplete; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentStages) { + pPresentStages = new VkPresentStageTimeEXT[copy_src.presentStageCount]; + memcpy((void*)pPresentStages, (void*)copy_src.pPresentStages, sizeof(VkPresentStageTimeEXT) * copy_src.presentStageCount); + } + + return *this; +} + +safe_VkPastPresentationTimingEXT::~safe_VkPastPresentationTimingEXT() { + if (pPresentStages) delete[] pPresentStages; + FreePnextChain(pNext); +} + +void safe_VkPastPresentationTimingEXT::initialize(const VkPastPresentationTimingEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentStages) delete[] pPresentStages; + FreePnextChain(pNext); + sType = in_struct->sType; + presentId = in_struct->presentId; + targetTime = in_struct->targetTime; + presentStageCount = in_struct->presentStageCount; + pPresentStages = nullptr; + timeDomain = in_struct->timeDomain; + timeDomainId = in_struct->timeDomainId; + reportComplete = in_struct->reportComplete; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPresentStages) { + pPresentStages = new VkPresentStageTimeEXT[in_struct->presentStageCount]; + memcpy((void*)pPresentStages, (void*)in_struct->pPresentStages, + sizeof(VkPresentStageTimeEXT) * in_struct->presentStageCount); + } +} + +void safe_VkPastPresentationTimingEXT::initialize(const safe_VkPastPresentationTimingEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentId = copy_src->presentId; + targetTime = copy_src->targetTime; + presentStageCount = copy_src->presentStageCount; + pPresentStages = nullptr; + timeDomain = copy_src->timeDomain; + timeDomainId = copy_src->timeDomainId; + reportComplete = copy_src->reportComplete; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPresentStages) { + pPresentStages = new VkPresentStageTimeEXT[copy_src->presentStageCount]; + memcpy((void*)pPresentStages, (void*)copy_src->pPresentStages, sizeof(VkPresentStageTimeEXT) * copy_src->presentStageCount); + } +} + +safe_VkPastPresentationTimingPropertiesEXT::safe_VkPastPresentationTimingPropertiesEXT( + const VkPastPresentationTimingPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + timingPropertiesCounter(in_struct->timingPropertiesCounter), + timeDomainsCounter(in_struct->timeDomainsCounter), + presentationTimingCount(in_struct->presentationTimingCount), + pPresentationTimings(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (presentationTimingCount && in_struct->pPresentationTimings) { + pPresentationTimings = new safe_VkPastPresentationTimingEXT[presentationTimingCount]; + for (uint32_t i = 0; i < presentationTimingCount; ++i) { + pPresentationTimings[i].initialize(&in_struct->pPresentationTimings[i]); + } + } +} + +safe_VkPastPresentationTimingPropertiesEXT::safe_VkPastPresentationTimingPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT), + pNext(nullptr), + timingPropertiesCounter(), + timeDomainsCounter(), + presentationTimingCount(), + pPresentationTimings(nullptr) {} + +safe_VkPastPresentationTimingPropertiesEXT::safe_VkPastPresentationTimingPropertiesEXT( + const safe_VkPastPresentationTimingPropertiesEXT& copy_src) { + sType = copy_src.sType; + timingPropertiesCounter = copy_src.timingPropertiesCounter; + timeDomainsCounter = copy_src.timeDomainsCounter; + presentationTimingCount = copy_src.presentationTimingCount; + pPresentationTimings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (presentationTimingCount && copy_src.pPresentationTimings) { + pPresentationTimings = new safe_VkPastPresentationTimingEXT[presentationTimingCount]; + for (uint32_t i = 0; i < presentationTimingCount; ++i) { + pPresentationTimings[i].initialize(©_src.pPresentationTimings[i]); + } + } +} + +safe_VkPastPresentationTimingPropertiesEXT& safe_VkPastPresentationTimingPropertiesEXT::operator=( + const safe_VkPastPresentationTimingPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + if (pPresentationTimings) delete[] pPresentationTimings; + FreePnextChain(pNext); + + sType = copy_src.sType; + timingPropertiesCounter = copy_src.timingPropertiesCounter; + timeDomainsCounter = copy_src.timeDomainsCounter; + presentationTimingCount = copy_src.presentationTimingCount; + pPresentationTimings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (presentationTimingCount && copy_src.pPresentationTimings) { + pPresentationTimings = new safe_VkPastPresentationTimingEXT[presentationTimingCount]; + for (uint32_t i = 0; i < presentationTimingCount; ++i) { + pPresentationTimings[i].initialize(©_src.pPresentationTimings[i]); + } + } + + return *this; +} + +safe_VkPastPresentationTimingPropertiesEXT::~safe_VkPastPresentationTimingPropertiesEXT() { + if (pPresentationTimings) delete[] pPresentationTimings; + FreePnextChain(pNext); +} + +void safe_VkPastPresentationTimingPropertiesEXT::initialize(const VkPastPresentationTimingPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentationTimings) delete[] pPresentationTimings; + FreePnextChain(pNext); + sType = in_struct->sType; + timingPropertiesCounter = in_struct->timingPropertiesCounter; + timeDomainsCounter = in_struct->timeDomainsCounter; + presentationTimingCount = in_struct->presentationTimingCount; + pPresentationTimings = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (presentationTimingCount && in_struct->pPresentationTimings) { + pPresentationTimings = new safe_VkPastPresentationTimingEXT[presentationTimingCount]; + for (uint32_t i = 0; i < presentationTimingCount; ++i) { + pPresentationTimings[i].initialize(&in_struct->pPresentationTimings[i]); + } + } +} + +void safe_VkPastPresentationTimingPropertiesEXT::initialize(const safe_VkPastPresentationTimingPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + timingPropertiesCounter = copy_src->timingPropertiesCounter; + timeDomainsCounter = copy_src->timeDomainsCounter; + presentationTimingCount = copy_src->presentationTimingCount; + pPresentationTimings = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (presentationTimingCount && copy_src->pPresentationTimings) { + pPresentationTimings = new safe_VkPastPresentationTimingEXT[presentationTimingCount]; + for (uint32_t i = 0; i < presentationTimingCount; ++i) { + pPresentationTimings[i].initialize(©_src->pPresentationTimings[i]); + } + } +} + +safe_VkPresentTimingInfoEXT::safe_VkPresentTimingInfoEXT(const VkPresentTimingInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + targetTime(in_struct->targetTime), + timeDomainId(in_struct->timeDomainId), + presentStageQueries(in_struct->presentStageQueries), + targetTimeDomainPresentStage(in_struct->targetTimeDomainPresentStage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPresentTimingInfoEXT::safe_VkPresentTimingInfoEXT() + : sType(VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT), + pNext(nullptr), + flags(), + targetTime(), + timeDomainId(), + presentStageQueries(), + targetTimeDomainPresentStage() {} + +safe_VkPresentTimingInfoEXT::safe_VkPresentTimingInfoEXT(const safe_VkPresentTimingInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + targetTime = copy_src.targetTime; + timeDomainId = copy_src.timeDomainId; + presentStageQueries = copy_src.presentStageQueries; + targetTimeDomainPresentStage = copy_src.targetTimeDomainPresentStage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPresentTimingInfoEXT& safe_VkPresentTimingInfoEXT::operator=(const safe_VkPresentTimingInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + targetTime = copy_src.targetTime; + timeDomainId = copy_src.timeDomainId; + presentStageQueries = copy_src.presentStageQueries; + targetTimeDomainPresentStage = copy_src.targetTimeDomainPresentStage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPresentTimingInfoEXT::~safe_VkPresentTimingInfoEXT() { FreePnextChain(pNext); } + +void safe_VkPresentTimingInfoEXT::initialize(const VkPresentTimingInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + targetTime = in_struct->targetTime; + timeDomainId = in_struct->timeDomainId; + presentStageQueries = in_struct->presentStageQueries; + targetTimeDomainPresentStage = in_struct->targetTimeDomainPresentStage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPresentTimingInfoEXT::initialize(const safe_VkPresentTimingInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + targetTime = copy_src->targetTime; + timeDomainId = copy_src->timeDomainId; + presentStageQueries = copy_src->presentStageQueries; + targetTimeDomainPresentStage = copy_src->targetTimeDomainPresentStage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPresentTimingsInfoEXT::safe_VkPresentTimingsInfoEXT(const VkPresentTimingsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pTimingInfos(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (swapchainCount && in_struct->pTimingInfos) { + pTimingInfos = new safe_VkPresentTimingInfoEXT[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pTimingInfos[i].initialize(&in_struct->pTimingInfos[i]); + } + } +} + +safe_VkPresentTimingsInfoEXT::safe_VkPresentTimingsInfoEXT() + : sType(VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT), pNext(nullptr), swapchainCount(), pTimingInfos(nullptr) {} + +safe_VkPresentTimingsInfoEXT::safe_VkPresentTimingsInfoEXT(const safe_VkPresentTimingsInfoEXT& copy_src) { + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pTimingInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (swapchainCount && copy_src.pTimingInfos) { + pTimingInfos = new safe_VkPresentTimingInfoEXT[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pTimingInfos[i].initialize(©_src.pTimingInfos[i]); + } + } +} + +safe_VkPresentTimingsInfoEXT& safe_VkPresentTimingsInfoEXT::operator=(const safe_VkPresentTimingsInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pTimingInfos) delete[] pTimingInfos; + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pTimingInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (swapchainCount && copy_src.pTimingInfos) { + pTimingInfos = new safe_VkPresentTimingInfoEXT[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pTimingInfos[i].initialize(©_src.pTimingInfos[i]); + } + } + + return *this; +} + +safe_VkPresentTimingsInfoEXT::~safe_VkPresentTimingsInfoEXT() { + if (pTimingInfos) delete[] pTimingInfos; + FreePnextChain(pNext); +} + +void safe_VkPresentTimingsInfoEXT::initialize(const VkPresentTimingsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTimingInfos) delete[] pTimingInfos; + FreePnextChain(pNext); + sType = in_struct->sType; + swapchainCount = in_struct->swapchainCount; + pTimingInfos = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (swapchainCount && in_struct->pTimingInfos) { + pTimingInfos = new safe_VkPresentTimingInfoEXT[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pTimingInfos[i].initialize(&in_struct->pTimingInfos[i]); + } + } +} + +void safe_VkPresentTimingsInfoEXT::initialize(const safe_VkPresentTimingsInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchainCount = copy_src->swapchainCount; + pTimingInfos = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (swapchainCount && copy_src->pTimingInfos) { + pTimingInfos = new safe_VkPresentTimingInfoEXT[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pTimingInfos[i].initialize(©_src->pTimingInfos[i]); + } + } +} + safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT( const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp index 83e9cba..da6f809 100644 --- a/src/vulkan/vk_safe_struct_utils.cpp +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -1294,6 +1294,18 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: safe_pNext = new safe_VkQueueFamilyCheckpointProperties2NV(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevicePresentTimingFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + safe_pNext = new safe_VkPresentTimingSurfaceCapabilitiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + safe_pNext = new safe_VkSwapchainCalibratedTimestampInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + safe_pNext = new safe_VkPresentTimingsInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: safe_pNext = new safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(reinterpret_cast(pNext), copy_state, false); break; @@ -3612,6 +3624,18 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: delete reinterpret_cast(header); break;