From 7d4cabfe47351f120e42173ca5b3f73ac93c7a28 Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Fri, 23 Aug 2024 10:33:16 -0700 Subject: [PATCH] build: Update to header 1.3.294 --- include/vulkan/utility/vk_dispatch_table.h | 10 + include/vulkan/utility/vk_safe_struct.hpp | 207 +++++ include/vulkan/utility/vk_struct_helper.hpp | 11 + include/vulkan/vk_enum_string_helper.h | 27 + scripts/known_good.json | 2 +- src/vulkan/vk_safe_struct_khr.cpp | 805 ++++++++++++++++++++ src/vulkan/vk_safe_struct_utils.cpp | 54 ++ 7 files changed, 1115 insertions(+), 1 deletion(-) diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h index cda0aea..75d7b01 100644 --- a/include/vulkan/utility/vk_dispatch_table.h +++ b/include/vulkan/utility/vk_dispatch_table.h @@ -461,6 +461,11 @@ typedef struct VkuDeviceDispatchTable_ { PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR; PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR; PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR; + PFN_vkCreatePipelineBinariesKHR CreatePipelineBinariesKHR; + PFN_vkDestroyPipelineBinaryKHR DestroyPipelineBinaryKHR; + PFN_vkGetPipelineKeyKHR GetPipelineKeyKHR; + PFN_vkGetPipelineBinaryDataKHR GetPipelineBinaryDataKHR; + PFN_vkReleaseCapturedPipelineDataKHR ReleaseCapturedPipelineDataKHR; PFN_vkCmdSetLineStippleKHR CmdSetLineStippleKHR; PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR; PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR; @@ -1058,6 +1063,11 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch table->GetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)gdpa(device, "vkGetRenderingAreaGranularityKHR"); table->GetDeviceImageSubresourceLayoutKHR = (PFN_vkGetDeviceImageSubresourceLayoutKHR)gdpa(device, "vkGetDeviceImageSubresourceLayoutKHR"); table->GetImageSubresourceLayout2KHR = (PFN_vkGetImageSubresourceLayout2KHR)gdpa(device, "vkGetImageSubresourceLayout2KHR"); + table->CreatePipelineBinariesKHR = (PFN_vkCreatePipelineBinariesKHR)gdpa(device, "vkCreatePipelineBinariesKHR"); + table->DestroyPipelineBinaryKHR = (PFN_vkDestroyPipelineBinaryKHR)gdpa(device, "vkDestroyPipelineBinaryKHR"); + table->GetPipelineKeyKHR = (PFN_vkGetPipelineKeyKHR)gdpa(device, "vkGetPipelineKeyKHR"); + table->GetPipelineBinaryDataKHR = (PFN_vkGetPipelineBinaryDataKHR)gdpa(device, "vkGetPipelineBinaryDataKHR"); + table->ReleaseCapturedPipelineDataKHR = (PFN_vkReleaseCapturedPipelineDataKHR)gdpa(device, "vkReleaseCapturedPipelineDataKHR"); table->CmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)gdpa(device, "vkCmdSetLineStippleKHR"); table->GetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsKHR"); table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)gdpa(device, "vkCmdBindDescriptorSets2KHR"); diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 277ada8..cb4e3b3 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -7912,6 +7912,213 @@ struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDevicePipelineBinaryFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineBinaries; + + safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src); + safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& operator=(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src); + safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(); + ~safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(); + void initialize(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineBinaryFeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePipelineBinaryFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelineBinaryPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineBinaryInternalCache; + VkBool32 pipelineBinaryInternalCacheControl; + VkBool32 pipelineBinaryPrefersInternalCache; + VkBool32 pipelineBinaryPrecompiledInternalCache; + VkBool32 pipelineBinaryCompressedData; + + safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src); + safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& operator=(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src); + safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(); + ~safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(); + void initialize(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineBinaryPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineBinaryPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDevicePipelineBinaryInternalCacheControlKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 disableInternalCache; + + safe_VkDevicePipelineBinaryInternalCacheControlKHR(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDevicePipelineBinaryInternalCacheControlKHR(const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src); + safe_VkDevicePipelineBinaryInternalCacheControlKHR& operator=( + const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src); + safe_VkDevicePipelineBinaryInternalCacheControlKHR(); + ~safe_VkDevicePipelineBinaryInternalCacheControlKHR(); + void initialize(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDevicePipelineBinaryInternalCacheControlKHR* copy_src, PNextCopyState* copy_state = {}); + VkDevicePipelineBinaryInternalCacheControlKHR* ptr() { + return reinterpret_cast(this); + } + VkDevicePipelineBinaryInternalCacheControlKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineBinaryKeyKHR { + VkStructureType sType; + void* pNext{}; + uint32_t keySize; + uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]; + + safe_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineBinaryKeyKHR(const safe_VkPipelineBinaryKeyKHR& copy_src); + safe_VkPipelineBinaryKeyKHR& operator=(const safe_VkPipelineBinaryKeyKHR& copy_src); + safe_VkPipelineBinaryKeyKHR(); + ~safe_VkPipelineBinaryKeyKHR(); + void initialize(const VkPipelineBinaryKeyKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineBinaryKeyKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineBinaryKeyKHR* ptr() { return reinterpret_cast(this); } + VkPipelineBinaryKeyKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineBinaryDataKHR { + size_t dataSize; + void* pData{}; + + safe_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR* in_struct, PNextCopyState* copy_state = {}); + safe_VkPipelineBinaryDataKHR(const safe_VkPipelineBinaryDataKHR& copy_src); + safe_VkPipelineBinaryDataKHR& operator=(const safe_VkPipelineBinaryDataKHR& copy_src); + safe_VkPipelineBinaryDataKHR(); + ~safe_VkPipelineBinaryDataKHR(); + void initialize(const VkPipelineBinaryDataKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineBinaryDataKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineBinaryDataKHR* ptr() { return reinterpret_cast(this); } + VkPipelineBinaryDataKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineBinaryKeysAndDataKHR { + uint32_t binaryCount; + safe_VkPipelineBinaryKeyKHR* pPipelineBinaryKeys{}; + safe_VkPipelineBinaryDataKHR* pPipelineBinaryData{}; + + safe_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR* in_struct, PNextCopyState* copy_state = {}); + safe_VkPipelineBinaryKeysAndDataKHR(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src); + safe_VkPipelineBinaryKeysAndDataKHR& operator=(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src); + safe_VkPipelineBinaryKeysAndDataKHR(); + ~safe_VkPipelineBinaryKeysAndDataKHR(); + void initialize(const VkPipelineBinaryKeysAndDataKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineBinaryKeysAndDataKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineBinaryKeysAndDataKHR* ptr() { return reinterpret_cast(this); } + VkPipelineBinaryKeysAndDataKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineCreateInfoKHR { + VkStructureType sType; + void* pNext{}; + + safe_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineCreateInfoKHR(const safe_VkPipelineCreateInfoKHR& copy_src); + safe_VkPipelineCreateInfoKHR& operator=(const safe_VkPipelineCreateInfoKHR& copy_src); + safe_VkPipelineCreateInfoKHR(); + ~safe_VkPipelineCreateInfoKHR(); + void initialize(const VkPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineBinaryCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + safe_VkPipelineBinaryKeysAndDataKHR* pKeysAndDataInfo{}; + VkPipeline pipeline; + safe_VkPipelineCreateInfoKHR* pPipelineCreateInfo{}; + + safe_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineBinaryCreateInfoKHR(const safe_VkPipelineBinaryCreateInfoKHR& copy_src); + safe_VkPipelineBinaryCreateInfoKHR& operator=(const safe_VkPipelineBinaryCreateInfoKHR& copy_src); + safe_VkPipelineBinaryCreateInfoKHR(); + ~safe_VkPipelineBinaryCreateInfoKHR(); + void initialize(const VkPipelineBinaryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineBinaryCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineBinaryCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineBinaryCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineBinaryInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t binaryCount; + VkPipelineBinaryKHR* pPipelineBinaries{}; + + safe_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineBinaryInfoKHR(const safe_VkPipelineBinaryInfoKHR& copy_src); + safe_VkPipelineBinaryInfoKHR& operator=(const safe_VkPipelineBinaryInfoKHR& copy_src); + safe_VkPipelineBinaryInfoKHR(); + ~safe_VkPipelineBinaryInfoKHR(); + void initialize(const VkPipelineBinaryInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineBinaryInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineBinaryInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineBinaryInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkReleaseCapturedPipelineDataInfoKHR { + VkStructureType sType; + void* pNext{}; + VkPipeline pipeline; + + safe_VkReleaseCapturedPipelineDataInfoKHR(const VkReleaseCapturedPipelineDataInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkReleaseCapturedPipelineDataInfoKHR(const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src); + safe_VkReleaseCapturedPipelineDataInfoKHR& operator=(const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src); + safe_VkReleaseCapturedPipelineDataInfoKHR(); + ~safe_VkReleaseCapturedPipelineDataInfoKHR(); + void initialize(const VkReleaseCapturedPipelineDataInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkReleaseCapturedPipelineDataInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkReleaseCapturedPipelineDataInfoKHR* ptr() { return reinterpret_cast(this); } + VkReleaseCapturedPipelineDataInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineBinaryDataInfoKHR { + VkStructureType sType; + void* pNext{}; + VkPipelineBinaryKHR pipelineBinary; + + safe_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineBinaryDataInfoKHR(const safe_VkPipelineBinaryDataInfoKHR& copy_src); + safe_VkPipelineBinaryDataInfoKHR& operator=(const safe_VkPipelineBinaryDataInfoKHR& copy_src); + safe_VkPipelineBinaryDataInfoKHR(); + ~safe_VkPipelineBinaryDataInfoKHR(); + void initialize(const VkPipelineBinaryDataInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineBinaryDataInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineBinaryDataInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineBinaryDataInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineBinaryHandlesInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t pipelineBinaryCount; + VkPipelineBinaryKHR* pPipelineBinaries{}; + + safe_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineBinaryHandlesInfoKHR(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src); + safe_VkPipelineBinaryHandlesInfoKHR& operator=(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src); + safe_VkPipelineBinaryHandlesInfoKHR(); + ~safe_VkPipelineBinaryHandlesInfoKHR(); + void initialize(const VkPipelineBinaryHandlesInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineBinaryHandlesInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineBinaryHandlesInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineBinaryHandlesInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; struct safe_VkCooperativeMatrixPropertiesKHR { VkStructureType sType; void* pNext{}; diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp index 3142695..faf95e5 100644 --- a/include/vulkan/utility/vk_struct_helper.hpp +++ b/include/vulkan/utility/vk_struct_helper.hpp @@ -424,6 +424,16 @@ template <> inline VkStructureType GetSType() { return template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; } @@ -1088,6 +1098,7 @@ template<> inline VkObjectType GetObjectType() { return VK_OBJ template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_VIDEO_SESSION_KHR; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; } +template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_PIPELINE_BINARY_KHR; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_CU_MODULE_NVX; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_CU_FUNCTION_NVX; } diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index 00982f0..a26e127 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -110,6 +110,10 @@ static inline const char* string_VkResult(VkResult input_value) { return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT"; case VK_INCOMPATIBLE_SHADER_BINARY_EXT: return "VK_INCOMPATIBLE_SHADER_BINARY_EXT"; + case VK_PIPELINE_BINARY_MISSING_KHR: + return "VK_PIPELINE_BINARY_MISSING_KHR"; + case VK_ERROR_NOT_ENOUGH_SPACE_KHR: + return "VK_ERROR_NOT_ENOUGH_SPACE_KHR"; default: return "Unhandled VkResult"; } @@ -1762,6 +1766,26 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT"; case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: + return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR"; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: + return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: + return "VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR"; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: + return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR"; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: + return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + return "VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR"; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: + return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: @@ -2122,6 +2146,8 @@ static inline const char* string_VkObjectType(VkObjectType input_value) { return "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV"; case VK_OBJECT_TYPE_SHADER_EXT: return "VK_OBJECT_TYPE_SHADER_EXT"; + case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: + return "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR"; default: return "Unhandled VkObjectType"; } @@ -8332,6 +8358,7 @@ static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_val if (input_value == VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT) return "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT"; if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; if (input_value == VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"; return "Unhandled VkPipelineCreateFlagBits2KHR"; } diff --git a/scripts/known_good.json b/scripts/known_good.json index 04506a4..4ed3bca 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.3.293" + "commit": "v1.3.294" }, { "name": "googletest", diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp index edbd7e2..be16aba 100644 --- a/src/vulkan/vk_safe_struct_khr.cpp +++ b/src/vulkan/vk_safe_struct_khr.cpp @@ -12163,6 +12163,811 @@ void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR( + const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelineBinaries(in_struct->pipelineBinaries) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR), pNext(nullptr), pipelineBinaries() {} + +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR( + const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) { + sType = copy_src.sType; + pipelineBinaries = copy_src.pipelineBinaries; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::operator=( + const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineBinaries = copy_src.pipelineBinaries; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::~safe_VkPhysicalDevicePipelineBinaryFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineBinaries = in_struct->pipelineBinaries; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineBinaries = copy_src->pipelineBinaries; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR( + const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pipelineBinaryInternalCache(in_struct->pipelineBinaryInternalCache), + pipelineBinaryInternalCacheControl(in_struct->pipelineBinaryInternalCacheControl), + pipelineBinaryPrefersInternalCache(in_struct->pipelineBinaryPrefersInternalCache), + pipelineBinaryPrecompiledInternalCache(in_struct->pipelineBinaryPrecompiledInternalCache), + pipelineBinaryCompressedData(in_struct->pipelineBinaryCompressedData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR), + pNext(nullptr), + pipelineBinaryInternalCache(), + pipelineBinaryInternalCacheControl(), + pipelineBinaryPrefersInternalCache(), + pipelineBinaryPrecompiledInternalCache(), + pipelineBinaryCompressedData() {} + +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR( + const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) { + sType = copy_src.sType; + pipelineBinaryInternalCache = copy_src.pipelineBinaryInternalCache; + pipelineBinaryInternalCacheControl = copy_src.pipelineBinaryInternalCacheControl; + pipelineBinaryPrefersInternalCache = copy_src.pipelineBinaryPrefersInternalCache; + pipelineBinaryPrecompiledInternalCache = copy_src.pipelineBinaryPrecompiledInternalCache; + pipelineBinaryCompressedData = copy_src.pipelineBinaryCompressedData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::operator=( + const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineBinaryInternalCache = copy_src.pipelineBinaryInternalCache; + pipelineBinaryInternalCacheControl = copy_src.pipelineBinaryInternalCacheControl; + pipelineBinaryPrefersInternalCache = copy_src.pipelineBinaryPrefersInternalCache; + pipelineBinaryPrecompiledInternalCache = copy_src.pipelineBinaryPrecompiledInternalCache; + pipelineBinaryCompressedData = copy_src.pipelineBinaryCompressedData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::~safe_VkPhysicalDevicePipelineBinaryPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineBinaryInternalCache = in_struct->pipelineBinaryInternalCache; + pipelineBinaryInternalCacheControl = in_struct->pipelineBinaryInternalCacheControl; + pipelineBinaryPrefersInternalCache = in_struct->pipelineBinaryPrefersInternalCache; + pipelineBinaryPrecompiledInternalCache = in_struct->pipelineBinaryPrecompiledInternalCache; + pipelineBinaryCompressedData = in_struct->pipelineBinaryCompressedData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineBinaryInternalCache = copy_src->pipelineBinaryInternalCache; + pipelineBinaryInternalCacheControl = copy_src->pipelineBinaryInternalCacheControl; + pipelineBinaryPrefersInternalCache = copy_src->pipelineBinaryPrefersInternalCache; + pipelineBinaryPrecompiledInternalCache = copy_src->pipelineBinaryPrecompiledInternalCache; + pipelineBinaryCompressedData = copy_src->pipelineBinaryCompressedData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR( + const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), disableInternalCache(in_struct->disableInternalCache) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR() + : sType(VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR), pNext(nullptr), disableInternalCache() {} + +safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR( + const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) { + sType = copy_src.sType; + disableInternalCache = copy_src.disableInternalCache; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDevicePipelineBinaryInternalCacheControlKHR& safe_VkDevicePipelineBinaryInternalCacheControlKHR::operator=( + const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + disableInternalCache = copy_src.disableInternalCache; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDevicePipelineBinaryInternalCacheControlKHR::~safe_VkDevicePipelineBinaryInternalCacheControlKHR() { FreePnextChain(pNext); } + +void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + disableInternalCache = in_struct->disableInternalCache; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize( + const safe_VkDevicePipelineBinaryInternalCacheControlKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + disableInternalCache = copy_src->disableInternalCache; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), keySize(in_struct->keySize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = in_struct->key[i]; + } +} + +safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR), pNext(nullptr), keySize() {} + +safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const safe_VkPipelineBinaryKeyKHR& copy_src) { + sType = copy_src.sType; + keySize = copy_src.keySize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = copy_src.key[i]; + } +} + +safe_VkPipelineBinaryKeyKHR& safe_VkPipelineBinaryKeyKHR::operator=(const safe_VkPipelineBinaryKeyKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + keySize = copy_src.keySize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = copy_src.key[i]; + } + + return *this; +} + +safe_VkPipelineBinaryKeyKHR::~safe_VkPipelineBinaryKeyKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineBinaryKeyKHR::initialize(const VkPipelineBinaryKeyKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + keySize = in_struct->keySize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = in_struct->key[i]; + } +} + +void safe_VkPipelineBinaryKeyKHR::initialize(const safe_VkPipelineBinaryKeyKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + keySize = copy_src->keySize; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = copy_src->key[i]; + } +} + +safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : dataSize(in_struct->dataSize), pData(nullptr) { + if (in_struct->pData != nullptr) { + auto temp = new std::byte[in_struct->dataSize]; + std::memcpy(temp, in_struct->pData, in_struct->dataSize); + pData = temp; + } +} + +safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR() : dataSize(), pData(nullptr) {} + +safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const safe_VkPipelineBinaryDataKHR& copy_src) { + dataSize = copy_src.dataSize; + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } +} + +safe_VkPipelineBinaryDataKHR& safe_VkPipelineBinaryDataKHR::operator=(const safe_VkPipelineBinaryDataKHR& copy_src) { + if (©_src == this) return *this; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + + dataSize = copy_src.dataSize; + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } + + return *this; +} + +safe_VkPipelineBinaryDataKHR::~safe_VkPipelineBinaryDataKHR() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } +} + +void safe_VkPipelineBinaryDataKHR::initialize(const VkPipelineBinaryDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + dataSize = in_struct->dataSize; + + if (in_struct->pData != nullptr) { + auto temp = new std::byte[in_struct->dataSize]; + std::memcpy(temp, in_struct->pData, in_struct->dataSize); + pData = temp; + } +} + +void safe_VkPipelineBinaryDataKHR::initialize(const safe_VkPipelineBinaryDataKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + dataSize = copy_src->dataSize; + + if (copy_src->pData != nullptr) { + auto temp = new std::byte[copy_src->dataSize]; + std::memcpy(temp, copy_src->pData, copy_src->dataSize); + pData = temp; + } +} + +safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : binaryCount(in_struct->binaryCount), pPipelineBinaryKeys(nullptr), pPipelineBinaryData(nullptr) { + if (binaryCount && in_struct->pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(&in_struct->pPipelineBinaryKeys[i]); + } + } + if (binaryCount && in_struct->pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(&in_struct->pPipelineBinaryData[i]); + } + } +} + +safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR() + : binaryCount(), pPipelineBinaryKeys(nullptr), pPipelineBinaryData(nullptr) {} + +safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) { + binaryCount = copy_src.binaryCount; + pPipelineBinaryKeys = nullptr; + pPipelineBinaryData = nullptr; + if (binaryCount && copy_src.pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(©_src.pPipelineBinaryKeys[i]); + } + } + if (binaryCount && copy_src.pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(©_src.pPipelineBinaryData[i]); + } + } +} + +safe_VkPipelineBinaryKeysAndDataKHR& safe_VkPipelineBinaryKeysAndDataKHR::operator=( + const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) { + if (©_src == this) return *this; + + if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; + if (pPipelineBinaryData) delete[] pPipelineBinaryData; + + binaryCount = copy_src.binaryCount; + pPipelineBinaryKeys = nullptr; + pPipelineBinaryData = nullptr; + if (binaryCount && copy_src.pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(©_src.pPipelineBinaryKeys[i]); + } + } + if (binaryCount && copy_src.pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(©_src.pPipelineBinaryData[i]); + } + } + + return *this; +} + +safe_VkPipelineBinaryKeysAndDataKHR::~safe_VkPipelineBinaryKeysAndDataKHR() { + if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; + if (pPipelineBinaryData) delete[] pPipelineBinaryData; +} + +void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const VkPipelineBinaryKeysAndDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; + if (pPipelineBinaryData) delete[] pPipelineBinaryData; + binaryCount = in_struct->binaryCount; + pPipelineBinaryKeys = nullptr; + pPipelineBinaryData = nullptr; + if (binaryCount && in_struct->pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(&in_struct->pPipelineBinaryKeys[i]); + } + } + if (binaryCount && in_struct->pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(&in_struct->pPipelineBinaryData[i]); + } + } +} + +void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const safe_VkPipelineBinaryKeysAndDataKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + binaryCount = copy_src->binaryCount; + pPipelineBinaryKeys = nullptr; + pPipelineBinaryData = nullptr; + if (binaryCount && copy_src->pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(©_src->pPipelineBinaryKeys[i]); + } + } + if (binaryCount && copy_src->pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(©_src->pPipelineBinaryData[i]); + } + } +} + +safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR() : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR), pNext(nullptr) {} + +safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const safe_VkPipelineCreateInfoKHR& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineCreateInfoKHR& safe_VkPipelineCreateInfoKHR::operator=(const safe_VkPipelineCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineCreateInfoKHR::~safe_VkPipelineCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineCreateInfoKHR::initialize(const VkPipelineCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineCreateInfoKHR::initialize(const safe_VkPipelineCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pKeysAndDataInfo(nullptr), pipeline(in_struct->pipeline), pPipelineCreateInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(in_struct->pKeysAndDataInfo); + if (in_struct->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(in_struct->pPipelineCreateInfo); +} + +safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR), + pNext(nullptr), + pKeysAndDataInfo(nullptr), + pipeline(), + pPipelineCreateInfo(nullptr) {} + +safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const safe_VkPipelineBinaryCreateInfoKHR& copy_src) { + sType = copy_src.sType; + pKeysAndDataInfo = nullptr; + pipeline = copy_src.pipeline; + pPipelineCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src.pKeysAndDataInfo); + if (copy_src.pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src.pPipelineCreateInfo); +} + +safe_VkPipelineBinaryCreateInfoKHR& safe_VkPipelineBinaryCreateInfoKHR::operator=( + const safe_VkPipelineBinaryCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pKeysAndDataInfo) delete pKeysAndDataInfo; + if (pPipelineCreateInfo) delete pPipelineCreateInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + pKeysAndDataInfo = nullptr; + pipeline = copy_src.pipeline; + pPipelineCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src.pKeysAndDataInfo); + if (copy_src.pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src.pPipelineCreateInfo); + + return *this; +} + +safe_VkPipelineBinaryCreateInfoKHR::~safe_VkPipelineBinaryCreateInfoKHR() { + if (pKeysAndDataInfo) delete pKeysAndDataInfo; + if (pPipelineCreateInfo) delete pPipelineCreateInfo; + FreePnextChain(pNext); +} + +void safe_VkPipelineBinaryCreateInfoKHR::initialize(const VkPipelineBinaryCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pKeysAndDataInfo) delete pKeysAndDataInfo; + if (pPipelineCreateInfo) delete pPipelineCreateInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + pKeysAndDataInfo = nullptr; + pipeline = in_struct->pipeline; + pPipelineCreateInfo = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(in_struct->pKeysAndDataInfo); + if (in_struct->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(in_struct->pPipelineCreateInfo); +} + +void safe_VkPipelineBinaryCreateInfoKHR::initialize(const safe_VkPipelineBinaryCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pKeysAndDataInfo = nullptr; + pipeline = copy_src->pipeline; + pPipelineCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src->pKeysAndDataInfo); + if (copy_src->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src->pPipelineCreateInfo); +} + +safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), binaryCount(in_struct->binaryCount), pPipelineBinaries(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (binaryCount && in_struct->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; + } + } +} + +safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR), pNext(nullptr), binaryCount(), pPipelineBinaries(nullptr) {} + +safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const safe_VkPipelineBinaryInfoKHR& copy_src) { + sType = copy_src.sType; + binaryCount = copy_src.binaryCount; + pPipelineBinaries = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (binaryCount && copy_src.pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; + } + } +} + +safe_VkPipelineBinaryInfoKHR& safe_VkPipelineBinaryInfoKHR::operator=(const safe_VkPipelineBinaryInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pPipelineBinaries) delete[] pPipelineBinaries; + FreePnextChain(pNext); + + sType = copy_src.sType; + binaryCount = copy_src.binaryCount; + pPipelineBinaries = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (binaryCount && copy_src.pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; + } + } + + return *this; +} + +safe_VkPipelineBinaryInfoKHR::~safe_VkPipelineBinaryInfoKHR() { + if (pPipelineBinaries) delete[] pPipelineBinaries; + FreePnextChain(pNext); +} + +void safe_VkPipelineBinaryInfoKHR::initialize(const VkPipelineBinaryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPipelineBinaries) delete[] pPipelineBinaries; + FreePnextChain(pNext); + sType = in_struct->sType; + binaryCount = in_struct->binaryCount; + pPipelineBinaries = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (binaryCount && in_struct->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; + } + } +} + +void safe_VkPipelineBinaryInfoKHR::initialize(const safe_VkPipelineBinaryInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + binaryCount = copy_src->binaryCount; + pPipelineBinaries = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (binaryCount && copy_src->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = copy_src->pPipelineBinaries[i]; + } + } +} + +safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR( + const VkReleaseCapturedPipelineDataInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipeline(in_struct->pipeline) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR() + : sType(VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR), pNext(nullptr), pipeline() {} + +safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR( + const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) { + sType = copy_src.sType; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkReleaseCapturedPipelineDataInfoKHR& safe_VkReleaseCapturedPipelineDataInfoKHR::operator=( + const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkReleaseCapturedPipelineDataInfoKHR::~safe_VkReleaseCapturedPipelineDataInfoKHR() { FreePnextChain(pNext); } + +void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const VkReleaseCapturedPipelineDataInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipeline = in_struct->pipeline; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const safe_VkReleaseCapturedPipelineDataInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipeline = copy_src->pipeline; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelineBinary(in_struct->pipelineBinary) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR), pNext(nullptr), pipelineBinary() {} + +safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const safe_VkPipelineBinaryDataInfoKHR& copy_src) { + sType = copy_src.sType; + pipelineBinary = copy_src.pipelineBinary; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineBinaryDataInfoKHR& safe_VkPipelineBinaryDataInfoKHR::operator=(const safe_VkPipelineBinaryDataInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineBinary = copy_src.pipelineBinary; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineBinaryDataInfoKHR::~safe_VkPipelineBinaryDataInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineBinaryDataInfoKHR::initialize(const VkPipelineBinaryDataInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineBinary = in_struct->pipelineBinary; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineBinaryDataInfoKHR::initialize(const safe_VkPipelineBinaryDataInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineBinary = copy_src->pipelineBinary; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pipelineBinaryCount(in_struct->pipelineBinaryCount), pPipelineBinaries(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (pipelineBinaryCount && in_struct->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; + } + } +} + +safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR), + pNext(nullptr), + pipelineBinaryCount(), + pPipelineBinaries(nullptr) {} + +safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) { + sType = copy_src.sType; + pipelineBinaryCount = copy_src.pipelineBinaryCount; + pPipelineBinaries = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (pipelineBinaryCount && copy_src.pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; + } + } +} + +safe_VkPipelineBinaryHandlesInfoKHR& safe_VkPipelineBinaryHandlesInfoKHR::operator=( + const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pPipelineBinaries) delete[] pPipelineBinaries; + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineBinaryCount = copy_src.pipelineBinaryCount; + pPipelineBinaries = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (pipelineBinaryCount && copy_src.pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; + } + } + + return *this; +} + +safe_VkPipelineBinaryHandlesInfoKHR::~safe_VkPipelineBinaryHandlesInfoKHR() { + if (pPipelineBinaries) delete[] pPipelineBinaries; + FreePnextChain(pNext); +} + +void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const VkPipelineBinaryHandlesInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPipelineBinaries) delete[] pPipelineBinaries; + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineBinaryCount = in_struct->pipelineBinaryCount; + pPipelineBinaries = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (pipelineBinaryCount && in_struct->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; + } + } +} + +void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const safe_VkPipelineBinaryHandlesInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineBinaryCount = copy_src->pipelineBinaryCount; + pPipelineBinaries = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (pipelineBinaryCount && copy_src->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = copy_src->pPipelineBinaries[i]; + } + } +} + safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp index 8b56c1e..f1a065a 100644 --- a/src/vulkan/vk_safe_struct_utils.cpp +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -60,6 +60,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: safe_pNext = new safe_VkShaderModuleCreateInfo(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: + safe_pNext = new safe_VkComputePipelineCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: + safe_pNext = new safe_VkGraphicsPipelineCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: safe_pNext = new safe_VkPipelineLayoutCreateInfo(reinterpret_cast(pNext), copy_state, false); break; @@ -704,6 +710,18 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + safe_pNext = new safe_VkDevicePipelineBinaryInternalCacheControlKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + safe_pNext = new safe_VkPipelineBinaryInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -919,6 +937,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: safe_pNext = new safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: + safe_pNext = new safe_VkExecutionGraphPipelineCreateInfoAMDX(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast(pNext), copy_state, false); break; @@ -986,6 +1007,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: + safe_pNext = new safe_VkRayTracingPipelineCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast(pNext), copy_state, false); break; @@ -1834,6 +1858,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: + safe_pNext = new safe_VkRayTracingPipelineCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -1898,6 +1925,12 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: delete reinterpret_cast(header); break; @@ -2542,6 +2575,18 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: delete reinterpret_cast(header); break; @@ -2757,6 +2802,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: delete reinterpret_cast(header); break; @@ -2824,6 +2872,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: delete reinterpret_cast(header); break; @@ -3672,6 +3723,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: delete reinterpret_cast(header); break;