eden-emu/Vulkan-Utility-Libraries
15
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git synced 2025-06-02 01:47:56 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

build: Update to header 1.3.294

Browse source
This commit is contained in:
Mike Schuchardt 2024-08-23 10:33:16 -07:00 • committed by Charles Giessen
parent 9b6e18888b
commit 7ea05992a5
7 changed files with 1115 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

10
include/vulkan/utility/vk_dispatch_table.h
View file

@ -461,6 +461,11 @@ typedef struct VkuDeviceDispatchTable_ {
PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR; PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR;
PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR; PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR;
PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR; PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR;
PFN_vkCreatePipelineBinariesKHR CreatePipelineBinariesKHR;
PFN_vkDestroyPipelineBinaryKHR DestroyPipelineBinaryKHR;
PFN_vkGetPipelineKeyKHR GetPipelineKeyKHR;
PFN_vkGetPipelineBinaryDataKHR GetPipelineBinaryDataKHR;
PFN_vkReleaseCapturedPipelineDataKHR ReleaseCapturedPipelineDataKHR;
PFN_vkCmdSetLineStippleKHR CmdSetLineStippleKHR; PFN_vkCmdSetLineStippleKHR CmdSetLineStippleKHR;
PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR; PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR;
PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR; PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR;
@ -1058,6 +1063,11 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
table->GetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)gdpa(device, "vkGetRenderingAreaGranularityKHR"); table->GetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)gdpa(device, "vkGetRenderingAreaGranularityKHR");
table->GetDeviceImageSubresourceLayoutKHR = (PFN_vkGetDeviceImageSubresourceLayoutKHR)gdpa(device, "vkGetDeviceImageSubresourceLayoutKHR"); table->GetDeviceImageSubresourceLayoutKHR = (PFN_vkGetDeviceImageSubresourceLayoutKHR)gdpa(device, "vkGetDeviceImageSubresourceLayoutKHR");
table->GetImageSubresourceLayout2KHR = (PFN_vkGetImageSubresourceLayout2KHR)gdpa(device, "vkGetImageSubresourceLayout2KHR"); 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->CmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)gdpa(device, "vkCmdSetLineStippleKHR");
table->GetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsKHR"); table->GetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsKHR");
table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)gdpa(device, "vkCmdBindDescriptorSets2KHR"); table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)gdpa(device, "vkCmdBindDescriptorSets2KHR");

207
include/vulkan/utility/vk_safe_struct.hpp
View file

@ -7912,6 +7912,213 @@ struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
return reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const*>(this); return reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const*>(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<VkPhysicalDevicePipelineBinaryFeaturesKHR*>(this); }
VkPhysicalDevicePipelineBinaryFeaturesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDevicePipelineBinaryFeaturesKHR const*>(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<VkPhysicalDevicePipelineBinaryPropertiesKHR*>(this);
}
VkPhysicalDevicePipelineBinaryPropertiesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDevicePipelineBinaryPropertiesKHR const*>(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<VkDevicePipelineBinaryInternalCacheControlKHR*>(this);
}
VkDevicePipelineBinaryInternalCacheControlKHR const* ptr() const {
return reinterpret_cast<VkDevicePipelineBinaryInternalCacheControlKHR const*>(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<VkPipelineBinaryKeyKHR*>(this); }
VkPipelineBinaryKeyKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryKeyKHR const*>(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<VkPipelineBinaryDataKHR*>(this); }
VkPipelineBinaryDataKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryDataKHR const*>(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<VkPipelineBinaryKeysAndDataKHR*>(this); }
VkPipelineBinaryKeysAndDataKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryKeysAndDataKHR const*>(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<VkPipelineCreateInfoKHR*>(this); }
VkPipelineCreateInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineCreateInfoKHR const*>(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<VkPipelineBinaryCreateInfoKHR*>(this); }
VkPipelineBinaryCreateInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryCreateInfoKHR const*>(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<VkPipelineBinaryInfoKHR*>(this); }
VkPipelineBinaryInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryInfoKHR const*>(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<VkReleaseCapturedPipelineDataInfoKHR*>(this); }
VkReleaseCapturedPipelineDataInfoKHR const* ptr() const {
return reinterpret_cast<VkReleaseCapturedPipelineDataInfoKHR const*>(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<VkPipelineBinaryDataInfoKHR*>(this); }
VkPipelineBinaryDataInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryDataInfoKHR const*>(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<VkPipelineBinaryHandlesInfoKHR*>(this); }
VkPipelineBinaryHandlesInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryHandlesInfoKHR const*>(this); }
};
struct safe_VkCooperativeMatrixPropertiesKHR { struct safe_VkCooperativeMatrixPropertiesKHR {
VkStructureType sType; VkStructureType sType;
void* pNext{}; void* pNext{};

11
include/vulkan/utility/vk_struct_helper.hpp
View file

@ -424,6 +424,16 @@ template <> inline VkStructureType GetSType<VkSubresourceLayout2KHR>() { return
template <> inline VkStructureType GetSType<VkPipelineCreateFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType<VkPipelineCreateFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkBufferUsageFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType<VkBufferUsageFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; } template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkDevicePipelineBinaryInternalCacheControlKHR>() { return VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; }
template <> inline VkStructureType GetSType<VkPipelineBinaryKeyKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR; }
template <> inline VkStructureType GetSType<VkPipelineCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPipelineBinaryCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPipelineBinaryInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; }
template <> inline VkStructureType GetSType<VkReleaseCapturedPipelineDataInfoKHR>() { return VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPipelineBinaryDataInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPipelineBinaryHandlesInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; }
template <> inline VkStructureType GetSType<VkCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; } template <> inline VkStructureType GetSType<VkCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; } template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; } template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
@ -1088,6 +1098,7 @@ template<> inline VkObjectType GetObjectType<VkDisplayModeKHR>() { return VK_OBJ
template<> inline VkObjectType GetObjectType<VkVideoSessionKHR>() { return VK_OBJECT_TYPE_VIDEO_SESSION_KHR; } template<> inline VkObjectType GetObjectType<VkVideoSessionKHR>() { return VK_OBJECT_TYPE_VIDEO_SESSION_KHR; }
template<> inline VkObjectType GetObjectType<VkVideoSessionParametersKHR>() { return VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; } template<> inline VkObjectType GetObjectType<VkVideoSessionParametersKHR>() { return VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; }
template<> inline VkObjectType GetObjectType<VkDeferredOperationKHR>() { return VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; } template<> inline VkObjectType GetObjectType<VkDeferredOperationKHR>() { return VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; }
template<> inline VkObjectType GetObjectType<VkPipelineBinaryKHR>() { return VK_OBJECT_TYPE_PIPELINE_BINARY_KHR; }
template<> inline VkObjectType GetObjectType<VkDebugReportCallbackEXT>() { return VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; } template<> inline VkObjectType GetObjectType<VkDebugReportCallbackEXT>() { return VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; }
template<> inline VkObjectType GetObjectType<VkCuModuleNVX>() { return VK_OBJECT_TYPE_CU_MODULE_NVX; } template<> inline VkObjectType GetObjectType<VkCuModuleNVX>() { return VK_OBJECT_TYPE_CU_MODULE_NVX; }
template<> inline VkObjectType GetObjectType<VkCuFunctionNVX>() { return VK_OBJECT_TYPE_CU_FUNCTION_NVX; } template<> inline VkObjectType GetObjectType<VkCuFunctionNVX>() { return VK_OBJECT_TYPE_CU_FUNCTION_NVX; }

27
include/vulkan/vk_enum_string_helper.h
View file

@ -110,6 +110,10 @@ static inline const char* string_VkResult(VkResult input_value) {
return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT"; return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT";
case VK_INCOMPATIBLE_SHADER_BINARY_EXT: case VK_INCOMPATIBLE_SHADER_BINARY_EXT:
return "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: default:
return "Unhandled VkResult"; 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"; return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT";
case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT:
return "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: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
return "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: 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"; return "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV";
case VK_OBJECT_TYPE_SHADER_EXT: case VK_OBJECT_TYPE_SHADER_EXT:
return "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: default:
return "Unhandled VkObjectType"; 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_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_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_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"; return "Unhandled VkPipelineCreateFlagBits2KHR";
} }

2
scripts/known_good.json
View file

@ -7,7 +7,7 @@
"sub_dir": "Vulkan-Headers", "sub_dir": "Vulkan-Headers",
"build_dir": "Vulkan-Headers/build", "build_dir": "Vulkan-Headers/build",
"install_dir": "Vulkan-Headers/build/install", "install_dir": "Vulkan-Headers/build/install",
"commit": "v1.3.293" "commit": "v1.3.294"
}, },
{ {
"name": "googletest", "name": "googletest",

805
src/vulkan/vk_safe_struct_khr.cpp
View file

@ -12163,6 +12163,811 @@ void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize(
pNext = SafePnextCopy(copy_src->pNext); 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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_src == this) return *this;
if (pData != nullptr) {
auto temp = reinterpret_cast<const std::byte*>(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<const std::byte*>(pData);
delete[] temp;
}
}
void safe_VkPipelineBinaryDataKHR::initialize(const VkPipelineBinaryDataKHR* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
if (pData != nullptr) {
auto temp = reinterpret_cast<const std::byte*>(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(&copy_src.pPipelineBinaryKeys[i]);
}
}
if (binaryCount && copy_src.pPipelineBinaryData) {
pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount];
for (uint32_t i = 0; i < binaryCount; ++i) {
pPipelineBinaryData[i].initialize(&copy_src.pPipelineBinaryData[i]);
}
}
}
safe_VkPipelineBinaryKeysAndDataKHR& safe_VkPipelineBinaryKeysAndDataKHR::operator=(
const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) {
if (&copy_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(&copy_src.pPipelineBinaryKeys[i]);
}
}
if (binaryCount && copy_src.pPipelineBinaryData) {
pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount];
for (uint32_t i = 0; i < binaryCount; ++i) {
pPipelineBinaryData[i].initialize(&copy_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(&copy_src->pPipelineBinaryKeys[i]);
}
}
if (binaryCount && copy_src->pPipelineBinaryData) {
pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount];
for (uint32_t i = 0; i < binaryCount; ++i) {
pPipelineBinaryData[i].initialize(&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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, safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, [[maybe_unused]] PNextCopyState* copy_state,
bool copy_pnext) bool copy_pnext)

54
src/vulkan/vk_safe_struct_utils.cpp
View file

@ -60,6 +60,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
safe_pNext = new safe_VkShaderModuleCreateInfo(reinterpret_cast<const VkShaderModuleCreateInfo *>(pNext), copy_state, false); safe_pNext = new safe_VkShaderModuleCreateInfo(reinterpret_cast<const VkShaderModuleCreateInfo *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
safe_pNext = new safe_VkComputePipelineCreateInfo(reinterpret_cast<const VkComputePipelineCreateInfo *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
safe_pNext = new safe_VkGraphicsPipelineCreateInfo(reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
safe_pNext = new safe_VkPipelineLayoutCreateInfo(reinterpret_cast<const VkPipelineLayoutCreateInfo *>(pNext), copy_state, false); safe_pNext = new safe_VkPipelineLayoutCreateInfo(reinterpret_cast<const VkPipelineLayoutCreateInfo *>(pNext), copy_state, false);
break; 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: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePipelineBinaryPropertiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
safe_pNext = new safe_VkDevicePipelineBinaryInternalCacheControlKHR(reinterpret_cast<const VkDevicePipelineBinaryInternalCacheControlKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
safe_pNext = new safe_VkPipelineBinaryInfoKHR(reinterpret_cast<const VkPipelineBinaryInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(pNext), copy_state, false);
break; break;
@ -919,6 +937,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
safe_pNext = new safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
safe_pNext = new safe_VkExecutionGraphPipelineCreateInfoAMDX(reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>(pNext), copy_state, false); safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>(pNext), copy_state, false);
break; 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: case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(pNext), copy_state, false); safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
safe_pNext = new safe_VkRayTracingPipelineCreateInfoNV(reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(pNext), copy_state, false); safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(pNext), copy_state, false);
break; break;
@ -1834,6 +1858,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
safe_pNext = new safe_VkRayTracingPipelineCreateInfoKHR(reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext), copy_state, false);
break; break;
@ -1898,6 +1925,12 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
delete reinterpret_cast<safe_VkShaderModuleCreateInfo *>(header); delete reinterpret_cast<safe_VkShaderModuleCreateInfo *>(header);
break; break;
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
delete reinterpret_cast<safe_VkComputePipelineCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
delete reinterpret_cast<safe_VkGraphicsPipelineCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
delete reinterpret_cast<safe_VkPipelineLayoutCreateInfo *>(header); delete reinterpret_cast<safe_VkPipelineLayoutCreateInfo *>(header);
break; break;
@ -2542,6 +2575,18 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
break; break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDevicePipelineBinaryFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkPhysicalDevicePipelineBinaryPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
delete reinterpret_cast<safe_VkDevicePipelineBinaryInternalCacheControlKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
delete reinterpret_cast<safe_VkPipelineBinaryInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(header);
break; break;
@ -2757,6 +2802,9 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
delete reinterpret_cast<safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
break; break;
case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
delete reinterpret_cast<safe_VkExecutionGraphPipelineCreateInfoAMDX *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
delete reinterpret_cast<safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header); delete reinterpret_cast<safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
break; break;
@ -2824,6 +2872,9 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
delete reinterpret_cast<safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header); delete reinterpret_cast<safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
break; break;
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
delete reinterpret_cast<safe_VkRayTracingPipelineCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureNV *>(header); delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
break; break;
@ -3672,6 +3723,9 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
break; break;
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
delete reinterpret_cast<safe_VkRayTracingPipelineCreateInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
break; break;